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

1925 lines
69KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

  3.  * Copyright (C) 2011-2014 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. 

  24. #include "CarlaEngine.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. 

  30. #ifdef HAVE_LIBLO

  31. #endif

  32. 

  33. #include "juce_audio_formats.h"

  34. 

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

  36. # include "juce_gui_basics.h"

  37. #else

  38. namespace juce {

  39. # include "juce_events/messages/juce_Initialisation.h"

  40. } // namespace juce

  41. #endif

  42. 

  43. namespace CB = CarlaBackend;

  44. using CB::EngineOptions;

  45. 

  46. // -------------------------------------------------------------------------------------------------------------------

  47. // Single, standalone engine

  48. 

  49. struct CarlaBackendStandalone {

  50.     CarlaEngine*       engine;

  51.     EngineCallbackFunc engineCallback;

  52.     void*              engineCallbackPtr;

  53. #ifndef BUILD_BRIDGE

  54.     EngineOptions      engineOptions;

  55. #endif

  56. 

  57.     FileCallbackFunc fileCallback;

  58.     void*            fileCallbackPtr;

  59. 

  60.     CarlaString lastError;

  61. 

  62.     CarlaBackendStandalone() noexcept

  63.         : engine(nullptr),

  64.           engineCallback(nullptr),

  65.           engineCallbackPtr(nullptr),

  66. #ifndef BUILD_BRIDGE

  67.           engineOptions(),

  68. #endif

  69.           fileCallback(nullptr),

  70.           fileCallbackPtr(nullptr),

  71.           lastError() {}

  72. 

  73.     ~CarlaBackendStandalone() noexcept

  74.     {

  75.         CARLA_SAFE_ASSERT(engine == nullptr);

  76.     }

  77. 

  78.     CARLA_PREVENT_HEAP_ALLOCATION

  79.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  80. };

  81. 

  82. CarlaBackendStandalone gStandalone;

  83. 

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

  85. // API

  86. 

  87. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  88. #include "CarlaHostCommon.cpp"

  89. 

  90. // -------------------------------------------------------------------------------------------------------------------

  91. 

  92. uint carla_get_engine_driver_count()

  93. {

  94.     carla_debug("carla_get_engine_driver_count()");

  95. 

  96.     return CarlaEngine::getDriverCount();

  97. }

  98. 

  99. const char* carla_get_engine_driver_name(uint index)

  100. {

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

  102. 

  103.     return CarlaEngine::getDriverName(index);

  104. }

  105. 

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

  107. {

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

  109. 

  110.     return CarlaEngine::getDriverDeviceNames(index);

  111. }

  112. 

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

  114. {

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

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

  117. 

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

  119.     {

  120.         static EngineDriverDeviceInfo devInfo;

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

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

  123. 

  124.         devInfo.hints       = ret->hints;

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

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

  127.         return &devInfo;

  128.     }

  129. 

  130.     return nullptr;

  131. }

  132. 

  133. // -------------------------------------------------------------------------------------------------------------------

  134. 

  135. CarlaEngine* carla_get_engine()

  136. {

  137.     carla_debug("carla_get_engine()");

  138. 

  139.     return gStandalone.engine;

  140. }

  141. 

  142. // -------------------------------------------------------------------------------------------------------------------

  143. 

  144. static void carla_engine_init_common()

  145. {

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

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

  148. 

  149. #ifdef BUILD_BRIDGE

  150.     using juce::File;

  151.     File juceBinaryDir(File::getSpecialLocation(File::currentExecutableFile).getParentDirectory());

  152. 

  153.     /*

  154.     if (const char* const uisAlwaysOnTop = std::getenv("ENGINE_OPTION_FORCE_STEREO"))

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

  156. 

  157.     if (const char* const uisAlwaysOnTop = std::getenv("ENGINE_OPTION_PREFER_PLUGIN_BRIDGES"))

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

  159. 

  160.     if (const char* const uisAlwaysOnTop = std::getenv("ENGINE_OPTION_PREFER_UI_BRIDGES"))

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

  162.     */

  163. 

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

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

  166. 

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

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

  169. 

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

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

  172. 

  173.     if (const char* const pathLADSPA = std::getenv("ENGINE_OPTION_PLUGIN_PATH_LADSPA"))

  174.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_LADSPA, pathLADSPA);

  175. 

  176.     if (const char* const pathDSSI = std::getenv("ENGINE_OPTION_PLUGIN_PATH_DSSI"))

  177.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_DSSI, pathDSSI);

  178. 

  179.     if (const char* const pathLV2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_LV2"))

  180.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_LV2, pathLV2);

  181. 

  182.     if (const char* const pathVST2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_VST2"))

  183.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_VST2, pathVST2);

  184. 

  185.     if (const char* const pathVST3 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_VST3"))

  186.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_VST3, pathVST3);

  187. 

  188.     if (const char* const pathAU = std::getenv("ENGINE_OPTION_PLUGIN_PATH_AU"))

  189.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_AU, pathAU);

  190. 

  191.     if (const char* const pathGIG = std::getenv("ENGINE_OPTION_PLUGIN_PATH_GIG"))

  192.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_GIG, pathGIG);

  193. 

  194.     if (const char* const pathSF2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_SF2"))

  195.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_SF2, pathSF2);

  196. 

  197.     if (const char* const pathSFZ = std::getenv("ENGINE_OPTION_PLUGIN_PATH_SFZ"))

  198.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_SFZ, pathSFZ);

  199. 

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

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

  202.     else

  203.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES,   0, juceBinaryDir.getFullPathName().toRawUTF8());

  204. 

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

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

  207.     else

  208.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES,  0, juceBinaryDir.getChildFile("resources").getFullPathName().toRawUTF8());

  209. 

  210.     if (const char* const preventBadBehaviour = std::getenv("ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR"))

  211.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR, (std::strcmp(preventBadBehaviour, "true") == 0) ? 1 : 0, nullptr);

  212. 

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

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

  215. #else

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

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

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

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

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

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

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

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

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

  225. 

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

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

  228. 

  229.     if (gStandalone.engineOptions.pathLADSPA != nullptr)

  230.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_LADSPA, gStandalone.engineOptions.pathLADSPA);

  231. 

  232.     if (gStandalone.engineOptions.pathDSSI != nullptr)

  233.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_DSSI, gStandalone.engineOptions.pathDSSI);

  234. 

  235.     if (gStandalone.engineOptions.pathLV2 != nullptr)

  236.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_LV2, gStandalone.engineOptions.pathLV2);

  237. 

  238.     if (gStandalone.engineOptions.pathVST2 != nullptr)

  239.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_VST2, gStandalone.engineOptions.pathVST2);

  240. 

  241.     if (gStandalone.engineOptions.pathVST3 != nullptr)

  242.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_VST3, gStandalone.engineOptions.pathVST3);

  243. 

  244.     if (gStandalone.engineOptions.pathAU != nullptr)

  245.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_AU, gStandalone.engineOptions.pathAU);

  246. 

  247.     if (gStandalone.engineOptions.pathGIG != nullptr)

  248.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_GIG, gStandalone.engineOptions.pathGIG);

  249. 

  250.     if (gStandalone.engineOptions.pathSF2 != nullptr)

  251.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_SF2, gStandalone.engineOptions.pathSF2);

  252. 

  253.     if (gStandalone.engineOptions.pathSFZ != nullptr)

  254.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_SFZ, gStandalone.engineOptions.pathSFZ);

  255. 

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

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

  258. 

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

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

  261. 

  262.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR,    gStandalone.engineOptions.preventBadBehaviour ? 1 : 0,  nullptr);

  263. 

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

  265.     {

  266.         char strBuf[STR_MAX+1];

  267.         strBuf[STR_MAX] = '\0';

  268.         std::snprintf(strBuf, STR_MAX, P_UINTPTR, gStandalone.engineOptions.frontendWinId);

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

  270.     }

  271.     else

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

  273. #endif

  274. }

  275. 

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

  277. {

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

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

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

  281. 

  282.     if (gStandalone.engine != nullptr)

  283.     {

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

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

  286.         return false;

  287.     }

  288. 

  289. #ifdef CARLA_OS_WIN

  290.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  291. #endif

  292. 

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

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

  295.     {

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

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

  298.     }

  299. 

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

  301. 

  302.     if (gStandalone.engine == nullptr)

  303.     {

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

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

  306.         return false;

  307.     }

  308. 

  309. #ifdef BUILD_BRIDGE

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

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

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

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

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

  315. #else

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

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

  318. #endif

  319. 

  320.     carla_engine_init_common();

  321. 

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

  323.     {

  324. #ifndef BUILD_BRIDGE

  325.         juce::initialiseJuce_GUI();

  326. #endif

  327.         gStandalone.lastError = "No error";

  328.         return true;

  329.     }

  330.     else

  331.     {

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

  333.         delete gStandalone.engine;

  334.         gStandalone.engine = nullptr;

  335.         return false;

  336.     }

  337. }

  338. 

  339. #ifdef BUILD_BRIDGE

  340. bool carla_engine_init_bridge(const char audioBaseName[6+1], const char rtClientBaseName[6+1], const char nonRtClientBaseName[6+1],

  341.                               const char nonRtServerBaseName[6+1], const char* clientName)

  342. {

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

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

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

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

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

  348.     carla_debug("carla_engine_init_bridge(\"%s\", \"%s\", \"%s\", \"%s\", \"%s\")", audioBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName, clientName);

  349. 

  350.     if (gStandalone.engine != nullptr)

  351.     {

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

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

  354.         return false;

  355.     }

  356. 

  357.     gStandalone.engine = CarlaEngine::newBridge(audioBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);

  358. 

  359.     if (gStandalone.engine == nullptr)

  360.     {

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

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

  363.         return false;

  364.     }

  365. 

  366.     carla_engine_init_common();

  367. 

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

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

  370. 

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

  372.     {

  373.         gStandalone.lastError = "No error";

  374.         return true;

  375.     }

  376.     else

  377.     {

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

  379.         delete gStandalone.engine;

  380.         gStandalone.engine = nullptr;

  381.         return false;

  382.     }

  383. }

  384. #endif

  385. 

  386. bool carla_engine_close()

  387. {

  388.     carla_debug("carla_engine_close()");

  389. 

  390.     if (gStandalone.engine == nullptr)

  391.     {

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

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

  394.         return false;

  395.     }

  396. 

  397.     gStandalone.engine->setAboutToClose();

  398.     gStandalone.engine->removeAllPlugins();

  399. 

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

  401. 

  402.     if (! closed)

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

  404. 

  405. #ifndef BUILD_BRIDGE

  406.     juce::shutdownJuce_GUI();

  407. #endif

  408.     delete gStandalone.engine;

  409.     gStandalone.engine = nullptr;

  410. 

  411.     return closed;

  412. }

  413. 

  414. void carla_engine_idle()

  415. {

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

  417. 

  418.     gStandalone.engine->idle();

  419. }

  420. 

  421. bool carla_is_engine_running()

  422. {

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

  424. }

  425. 

  426. void carla_set_engine_about_to_close()

  427. {

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

  429.     carla_debug("carla_set_engine_about_to_close()");

  430. 

  431.     gStandalone.engine->setAboutToClose();

  432. }

  433. 

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

  435. {

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

  437. 

  438.     gStandalone.engineCallback    = func;

  439.     gStandalone.engineCallbackPtr = ptr;

  440. 

  441.     if (gStandalone.engine != nullptr)

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

  443. 

  444. //#ifdef WANT_LOGS

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

  446. //#endif

  447. }

  448. 

  449. #ifndef BUILD_BRIDGE

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

  451. {

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

  453. 

  454.     switch (option)

  455.     {

  456.     case CB::ENGINE_OPTION_DEBUG:

  457.         break;

  458. 

  459.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  462.         break;

  463. 

  464.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  467.         break;

  468. 

  469.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  472.         break;

  473. 

  474.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  477.         break;

  478. 

  479.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  482.         break;

  483. 

  484.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  487.         break;

  488. 

  489.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  490.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  492.         break;

  493. 

  494.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  495.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  497.         break;

  498. 

  499.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  502.         break;

  503. 

  504.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  505.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  507.         break;

  508. 

  509.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  510.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  512.         break;

  513. 

  514.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  515.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  516. 

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

  518.             delete[] gStandalone.engineOptions.audioDevice;

  519. 

  520.         gStandalone.engineOptions.audioDevice = carla_strdup_safe(valueStr);

  521.         break;

  522. 

  523.     case CB::ENGINE_OPTION_PLUGIN_PATH:

  524.         CARLA_SAFE_ASSERT_RETURN(value > CB::PLUGIN_NONE,);

  525.         CARLA_SAFE_ASSERT_RETURN(value <= CB::PLUGIN_SFZ,);

  526.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  527. 

  528.         switch (value)

  529.         {

  530.         case CB::PLUGIN_LADSPA:

  531.             if (gStandalone.engineOptions.pathLADSPA != nullptr)

  532.                 delete[] gStandalone.engineOptions.pathLADSPA;

  533.             gStandalone.engineOptions.pathLADSPA = carla_strdup_safe(valueStr);

  534.             break;

  535.         case CB::PLUGIN_DSSI:

  536.             if (gStandalone.engineOptions.pathDSSI != nullptr)

  537.                 delete[] gStandalone.engineOptions.pathDSSI;

  538.             gStandalone.engineOptions.pathDSSI = carla_strdup_safe(valueStr);

  539.             break;

  540.         case CB::PLUGIN_LV2:

  541.             if (gStandalone.engineOptions.pathLV2 != nullptr)

  542.                 delete[] gStandalone.engineOptions.pathLV2;

  543.             gStandalone.engineOptions.pathLV2 = carla_strdup_safe(valueStr);

  544.             break;

  545.         case CB::PLUGIN_VST2:

  546.             if (gStandalone.engineOptions.pathVST2 != nullptr)

  547.                 delete[] gStandalone.engineOptions.pathVST2;

  548.             gStandalone.engineOptions.pathVST2 = carla_strdup_safe(valueStr);

  549.             break;

  550.         case CB::PLUGIN_VST3:

  551.             if (gStandalone.engineOptions.pathVST3 != nullptr)

  552.                 delete[] gStandalone.engineOptions.pathVST3;

  553.             gStandalone.engineOptions.pathVST3 = carla_strdup_safe(valueStr);

  554.             break;

  555.         case CB::PLUGIN_AU:

  556.             if (gStandalone.engineOptions.pathAU != nullptr)

  557.                 delete[] gStandalone.engineOptions.pathAU;

  558.             gStandalone.engineOptions.pathAU = carla_strdup_safe(valueStr);

  559.             break;

  560.         case CB::PLUGIN_GIG:

  561.             if (gStandalone.engineOptions.pathGIG != nullptr)

  562.                 delete[] gStandalone.engineOptions.pathGIG;

  563.             gStandalone.engineOptions.pathGIG = carla_strdup_safe(valueStr);

  564.             break;

  565.         case CB::PLUGIN_SF2:

  566.             if (gStandalone.engineOptions.pathSF2 != nullptr)

  567.                 delete[] gStandalone.engineOptions.pathSF2;

  568.             gStandalone.engineOptions.pathSF2 = carla_strdup_safe(valueStr);

  569.             break;

  570.         case CB::PLUGIN_SFZ:

  571.             if (gStandalone.engineOptions.pathSFZ != nullptr)

  572.                 delete[] gStandalone.engineOptions.pathSFZ;

  573.             gStandalone.engineOptions.pathSFZ = carla_strdup_safe(valueStr);

  574.             break;

  575.         }

  576.         break;

  577. 

  578.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  580. 

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

  582.             delete[] gStandalone.engineOptions.binaryDir;

  583. 

  584.         gStandalone.engineOptions.binaryDir = carla_strdup_safe(valueStr);

  585.         break;

  586. 

  587.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  589. 

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

  591.             delete[] gStandalone.engineOptions.resourceDir;

  592. 

  593.         gStandalone.engineOptions.resourceDir = carla_strdup_safe(valueStr);

  594.         break;

  595. 

  596.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

  598.         gStandalone.engineOptions.preventBadBehaviour = (value != 0);

  599.         break;

  600. 

  601.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  604.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  606.         break;

  607.     }

  608. 

  609.     if (gStandalone.engine != nullptr)

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

  611. }

  612. #endif

  613. 

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

  615. {

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

  617. 

  618.     gStandalone.fileCallback    = func;

  619.     gStandalone.fileCallbackPtr = ptr;

  620. 

  621.     if (gStandalone.engine != nullptr)

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

  623. }

  624. 

  625. // -------------------------------------------------------------------------------------------------------------------

  626. 

  627. bool carla_load_file(const char* filename)

  628. {

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

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

  631. 

  632.     if (gStandalone.engine != nullptr)

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

  634. 

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

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

  637.     return false;

  638. }

  639. 

  640. bool carla_load_project(const char* filename)

  641. {

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

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

  644. 

  645.     if (gStandalone.engine != nullptr)

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

  647. 

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

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

  650.     return false;

  651. }

  652. 

  653. bool carla_save_project(const char* filename)

  654. {

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

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

  657. 

  658.     if (gStandalone.engine != nullptr)

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

  660. 

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

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

  663.     return false;

  664. }

  665. 

  666. #ifndef BUILD_BRIDGE

  667. // -------------------------------------------------------------------------------------------------------------------

  668. 

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

  670. {

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

  672. 

  673.     if (gStandalone.engine != nullptr)

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

  675. 

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

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

  678.     return false;

  679. }

  680. 

  681. bool carla_patchbay_disconnect(uint connectionId)

  682. {

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

  684. 

  685.     if (gStandalone.engine != nullptr)

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

  687. 

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

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

  690.     return false;

  691. }

  692. 

  693. bool carla_patchbay_refresh(bool external)

  694. {

  695.     carla_debug("carla_patchbay_refresh(%s)", bool2str(external));

  696. 

  697.     if (gStandalone.engine != nullptr)

  698.         return gStandalone.engine->patchbayRefresh(external);

  699. 

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

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

  702.     return false;

  703. }

  704. 

  705. // -------------------------------------------------------------------------------------------------------------------

  706. 

  707. void carla_transport_play()

  708. {

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

  710.     carla_debug("carla_transport_play()");

  711. 

  712.     gStandalone.engine->transportPlay();

  713. }

  714. 

  715. void carla_transport_pause()

  716. {

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

  718.     carla_debug("carla_transport_pause()");

  719. 

  720.     gStandalone.engine->transportPause();

  721. }

  722. 

  723. void carla_transport_relocate(uint64_t frame)

  724. {

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

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

  727. 

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

  729. }

  730. 

  731. uint64_t carla_get_current_transport_frame()

  732. {

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

  734. 

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

  736.     return timeInfo.frame;

  737. }

  738. 

  739. const CarlaTransportInfo* carla_get_transport_info()

  740. {

  741.     static CarlaTransportInfo retInfo;

  742. 

  743.     // reset

  744.     retInfo.playing = false;

  745.     retInfo.frame   = 0;

  746.     retInfo.bar     = 0;

  747.     retInfo.beat    = 0;

  748.     retInfo.tick    = 0;

  749.     retInfo.bpm     = 0.0;

  750. 

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

  752. 

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

  754. 

  755.     retInfo.playing = timeInfo.playing;

  756.     retInfo.frame   = timeInfo.frame;

  757. 

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

  759.     {

  760.         retInfo.bar  = timeInfo.bbt.bar;

  761.         retInfo.beat = timeInfo.bbt.beat;

  762.         retInfo.tick = timeInfo.bbt.tick;

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

  764.     }

  765. 

  766.     return &retInfo;

  767. }

  768. #endif

  769. 

  770. // -------------------------------------------------------------------------------------------------------------------

  771. 

  772. uint32_t carla_get_current_plugin_count()

  773. {

  774.     if (gStandalone.engine != nullptr)

  775.         return gStandalone.engine->getCurrentPluginCount();

  776. 

  777.     return 0;

  778. }

  779. 

  780. uint32_t carla_get_max_plugin_number()

  781. {

  782.     if (gStandalone.engine != nullptr)

  783.         return gStandalone.engine->getMaxPluginNumber();

  784. 

  785.     return 0;

  786. }

  787. 

  788. // -------------------------------------------------------------------------------------------------------------------

  789. 

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

  791. {

  792.     carla_debug("carla_add_plugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p, %u)", btype, CB::BinaryType2Str(btype), ptype, CB::PluginType2Str(ptype), filename, name, label, uniqueId, extraPtr, options);

  793. 

  794.     if (gStandalone.engine != nullptr)

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

  796. 

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

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

  799.     return false;

  800. }

  801. 

  802. bool carla_remove_plugin(uint pluginId)

  803. {

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

  805. 

  806.     if (gStandalone.engine != nullptr)

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

  808. 

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

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

  811.     return false;

  812. }

  813. 

  814. bool carla_remove_all_plugins()

  815. {

  816.     carla_debug("carla_remove_all_plugins()");

  817. 

  818.     if (gStandalone.engine != nullptr)

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

  820. 

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

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

  823.     return false;

  824. }

  825. 

  826. #ifndef BUILD_BRIDGE

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

  828. {

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

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

  831. 

  832.     if (gStandalone.engine != nullptr)

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

  834. 

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

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

  837.     return nullptr;

  838. }

  839. 

  840. bool carla_clone_plugin(uint pluginId)

  841. {

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

  843. 

  844.     if (gStandalone.engine != nullptr)

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

  846. 

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

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

  849.     return false;

  850. }

  851. 

  852. bool carla_replace_plugin(uint pluginId)

  853. {

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

  855. 

  856.     if (gStandalone.engine != nullptr)

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

  858. 

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

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

  861.     return false;

  862. }

  863. 

  864. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  865. {

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

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

  868. 

  869.     if (gStandalone.engine != nullptr)

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

  871. 

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

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

  874.     return false;

  875. }

  876. #endif

  877. 

  878. // -------------------------------------------------------------------------------------------------------------------

  879. 

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

  881. {

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

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

  884. 

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

  886.     {

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

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

  889.         return false;

  890.     }

  891. 

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

  893.         return plugin->loadStateFromFile(filename);

  894. 

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

  896.     return false;

  897. }

  898. 

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

  900. {

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

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

  903. 

  904.     if (gStandalone.engine == nullptr)

  905.     {

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

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

  908.         return false;

  909.     }

  910. 

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

  912. 

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

  914.         return plugin->saveStateToFile(filename);

  915. 

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

  917.     return false;

  918. }

  919. 

  920. // -------------------------------------------------------------------------------------------------------------------

  921. 

  922. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  923. {

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

  925. 

  926.     static CarlaPluginInfo info;

  927. 

  928.     // reset

  929.     info.type             = CB::PLUGIN_NONE;

  930.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  931.     info.hints            = 0x0;

  932.     info.optionsAvailable = 0x0;

  933.     info.optionsEnabled   = 0x0;

  934.     info.filename         = gNullCharPtr;

  935.     info.name             = gNullCharPtr;

  936.     info.iconName         = gNullCharPtr;

  937.     info.uniqueId         = 0;

  938. 

  939.     // cleanup

  940.     if (info.label != gNullCharPtr)

  941.     {

  942.         delete[] info.label;

  943.         info.label = gNullCharPtr;

  944.     }

  945. 

  946.     if (info.maker != gNullCharPtr)

  947.     {

  948.         delete[] info.maker;

  949.         info.maker = gNullCharPtr;

  950.     }

  951. 

  952.     if (info.copyright != gNullCharPtr)

  953.     {

  954.         delete[] info.copyright;

  955.         info.copyright = gNullCharPtr;

  956.     }

  957. 

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

  959. 

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

  961.     {

  962.         char strBufLabel[STR_MAX+1];

  963.         char strBufMaker[STR_MAX+1];

  964.         char strBufCopyright[STR_MAX+1];

  965. 

  966.         carla_zeroChar(strBufLabel, STR_MAX+1);

  967.         carla_zeroChar(strBufMaker, STR_MAX+1);

  968.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  969. 

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

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

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

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

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

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

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

  977. 

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

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

  980. 

  981.         plugin->getLabel(strBufLabel);

  982.         info.label = carla_strdup_safe(strBufLabel);

  983. 

  984.         plugin->getMaker(strBufMaker);

  985.         info.maker = carla_strdup_safe(strBufMaker);

  986. 

  987.         plugin->getCopyright(strBufCopyright);

  988.         info.copyright = carla_strdup_safe(strBufCopyright);

  989. 

  990.         checkStringPtr(info.filename);

  991.         checkStringPtr(info.name);

  992.         checkStringPtr(info.iconName);

  993.         checkStringPtr(info.label);

  994.         checkStringPtr(info.maker);

  995.         checkStringPtr(info.copyright);

  996. 

  997.         return &info;

  998.     }

  999. 

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

  1001.     return &info;

  1002. }

  1003. 

  1004. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1005. {

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

  1007. 

  1008.     static CarlaPortCountInfo info;

  1009. 

  1010.     // reset

  1011.     info.ins   = 0;

  1012.     info.outs  = 0;

  1013. 

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

  1015. 

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

  1017.     {

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

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

  1020.         return &info;

  1021.     }

  1022. 

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

  1024.     return &info;

  1025. }

  1026. 

  1027. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1028. {

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

  1030. 

  1031.     static CarlaPortCountInfo info;

  1032. 

  1033.     // reset

  1034.     info.ins   = 0;

  1035.     info.outs  = 0;

  1036. 

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

  1038. 

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

  1040.     {

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

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

  1043.         return &info;

  1044.     }

  1045. 

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

  1047.     return &info;

  1048. }

  1049. 

  1050. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1051. {

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

  1053. 

  1054.     static CarlaPortCountInfo info;

  1055. 

  1056.     // reset

  1057.     info.ins   = 0;

  1058.     info.outs  = 0;

  1059. 

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

  1061. 

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

  1063.     {

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

  1065.         return &info;

  1066.     }

  1067. 

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

  1069.     return &info;

  1070. }

  1071. 

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

  1073. {

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

  1075. 

  1076.     static CarlaParameterInfo info;

  1077. 

  1078.     // reset

  1079.     info.scalePointCount = 0;

  1080. 

  1081.     // cleanup

  1082.     if (info.name != gNullCharPtr)

  1083.     {

  1084.         delete[] info.name;

  1085.         info.name = gNullCharPtr;

  1086.     }

  1087. 

  1088.     if (info.symbol != gNullCharPtr)

  1089.     {

  1090.         delete[] info.symbol;

  1091.         info.symbol = gNullCharPtr;

  1092.     }

  1093. 

  1094.     if (info.unit != gNullCharPtr)

  1095.     {

  1096.         delete[] info.unit;

  1097.         info.unit = gNullCharPtr;

  1098.     }

  1099. 

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

  1101. 

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

  1103.     {

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

  1105.         {

  1106.             char strBufName[STR_MAX+1];

  1107.             char strBufSymbol[STR_MAX+1];

  1108.             char strBufUnit[STR_MAX+1];

  1109. 

  1110.             carla_zeroChar(strBufName, STR_MAX+1);

  1111.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1112.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1113. 

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

  1115. 

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

  1117.             info.name = carla_strdup_safe(strBufName);

  1118. 

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

  1120.             info.symbol = carla_strdup_safe(strBufSymbol);

  1121. 

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

  1123.             info.unit = carla_strdup_safe(strBufUnit);

  1124. 

  1125.             checkStringPtr(info.name);

  1126.             checkStringPtr(info.symbol);

  1127.             checkStringPtr(info.unit);

  1128.         }

  1129.         else

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

  1131. 

  1132.         return &info;

  1133.     }

  1134. 

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

  1136.     return &info;

  1137. }

  1138. 

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

  1140. {

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

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

  1143. 

  1144.     static CarlaScalePointInfo info;

  1145. 

  1146.     // reset

  1147.     info.value = 0.0f;

  1148. 

  1149.     // cleanup

  1150.     if (info.label != gNullCharPtr)

  1151.     {

  1152.         delete[] info.label;

  1153.         info.label = gNullCharPtr;

  1154.     }

  1155. 

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

  1157. 

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

  1159.     {

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

  1161.         {

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

  1163.             {

  1164.                 char strBufLabel[STR_MAX+1];

  1165.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1166. 

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

  1168. 

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

  1170.                 info.label = carla_strdup_safe(strBufLabel);

  1171.                 checkStringPtr(info.label);

  1172.             }

  1173.             else

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

  1175.         }

  1176.         else

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

  1178. 

  1179.         return &info;

  1180.     }

  1181. 

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

  1183.     return &info;

  1184. }

  1185. 

  1186. // -------------------------------------------------------------------------------------------------------------------

  1187. 

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

  1189. {

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

  1191. 

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

  1193. 

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

  1195. 

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

  1197.     {

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

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

  1200. 

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

  1202.         return &fallbackParameterData;

  1203.     }

  1204. 

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

  1206.     return &fallbackParameterData;

  1207. }

  1208. 

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

  1210. {

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

  1212. 

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

  1214. 

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

  1216. 

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

  1218.     {

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

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

  1221. 

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

  1223.         return &fallbackParamRanges;

  1224.     }

  1225. 

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

  1227.     return &fallbackParamRanges;

  1228. }

  1229. 

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

  1231. {

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

  1233. 

  1234.     static MidiProgramData midiProgData;

  1235. 

  1236.     // reset

  1237.     midiProgData.bank    = 0;

  1238.     midiProgData.program = 0;

  1239.     midiProgData.name    = gNullCharPtr;

  1240. 

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

  1242. 

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

  1244.     {

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

  1246.         {

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

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

  1249.             checkStringPtr(midiProgData.name);

  1250.             return &midiProgData;

  1251.         }

  1252. 

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

  1254.         return &midiProgData;

  1255.     }

  1256. 

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

  1258.     return &midiProgData;

  1259. }

  1260. 

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

  1262. {

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

  1264. 

  1265.     static CustomData customData;

  1266. 

  1267.     // reset

  1268.     customData.type  = gNullCharPtr;

  1269.     customData.key   = gNullCharPtr;

  1270.     customData.value = gNullCharPtr;

  1271. 

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

  1273. 

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

  1275.     {

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

  1277.         {

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

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

  1280.             checkStringPtr(customData.type);

  1281.             checkStringPtr(customData.key);

  1282.             checkStringPtr(customData.value);

  1283.             return &customData;

  1284.         }

  1285. 

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

  1287.         return &customData;

  1288.     }

  1289. 

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

  1291.     return &customData;

  1292. }

  1293. 

  1294. const char* carla_get_chunk_data(uint pluginId)

  1295. {

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

  1297. 

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

  1299. 

  1300.     static CarlaString chunkData;

  1301. 

  1302.     // cleanup

  1303.     chunkData.clear();

  1304. 

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

  1306.     {

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

  1308.         {

  1309.             void* data = nullptr;

  1310.             const std::size_t dataSize(plugin->getChunkData(&data));

  1311. 

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

  1313.             {

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

  1315.                 return chunkData;

  1316.             }

  1317.             else

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

  1319.         }

  1320.         else

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

  1322. 

  1323.         return nullptr;

  1324.     }

  1325. 

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

  1327.     return nullptr;

  1328. }

  1329. 

  1330. // -------------------------------------------------------------------------------------------------------------------

  1331. 

  1332. uint32_t carla_get_parameter_count(uint pluginId)

  1333. {

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

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

  1336. 

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

  1338.         return plugin->getParameterCount();

  1339. 

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

  1341.     return 0;

  1342. }

  1343. 

  1344. uint32_t carla_get_program_count(uint pluginId)

  1345. {

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

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

  1348. 

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

  1350.         return plugin->getProgramCount();

  1351. 

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

  1353.     return 0;

  1354. }

  1355. 

  1356. uint32_t carla_get_midi_program_count(uint pluginId)

  1357. {

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

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

  1360. 

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

  1362.         return plugin->getMidiProgramCount();

  1363. 

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

  1365.     return 0;

  1366. }

  1367. 

  1368. uint32_t carla_get_custom_data_count(uint pluginId)

  1369. {

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

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

  1372. 

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

  1374.         return plugin->getCustomDataCount();

  1375. 

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

  1377.     return 0;

  1378. }

  1379. 

  1380. // -------------------------------------------------------------------------------------------------------------------

  1381. 

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

  1383. {

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

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

  1386. 

  1387.     static char textBuf[STR_MAX+1];

  1388. 

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

  1390.     {

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

  1392.         {

  1393.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1395.             return textBuf;

  1396.         }

  1397. 

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

  1399.         return nullptr;

  1400.     }

  1401. 

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

  1403.     return nullptr;

  1404. }

  1405. 

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

  1407. {

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

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

  1410. 

  1411.     static char programName[STR_MAX+1];

  1412. 

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

  1414.     {

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

  1416.         {

  1417.             carla_zeroChar(programName, STR_MAX+1);

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

  1419.             return programName;

  1420.         }

  1421. 

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

  1423.         return nullptr;

  1424.     }

  1425. 

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

  1427.     return nullptr;

  1428. }

  1429. 

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

  1431. {

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

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

  1434. 

  1435.     static char midiProgramName[STR_MAX+1];

  1436. 

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

  1438.     {

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

  1440.         {

  1441.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1443.             return midiProgramName;

  1444.         }

  1445. 

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

  1447.         return nullptr;

  1448.     }

  1449. 

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

  1451.     return nullptr;

  1452. }

  1453. 

  1454. const char* carla_get_real_plugin_name(uint pluginId)

  1455. {

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

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

  1458. 

  1459.     static char realPluginName[STR_MAX+1];

  1460. 

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

  1462.     {

  1463.         carla_zeroChar(realPluginName, STR_MAX+1);

  1464.         plugin->getRealName(realPluginName);

  1465.         return realPluginName;

  1466.     }

  1467. 

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

  1469.     return nullptr;

  1470. }

  1471. 

  1472. // -------------------------------------------------------------------------------------------------------------------

  1473. 

  1474. int32_t carla_get_current_program_index(uint pluginId)

  1475. {

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

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

  1478. 

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

  1480.         return plugin->getCurrentProgram();

  1481. 

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

  1483.     return -1;

  1484. }

  1485. 

  1486. int32_t carla_get_current_midi_program_index(uint pluginId)

  1487. {

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

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

  1490. 

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

  1492.         return plugin->getCurrentMidiProgram();

  1493. 

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

  1495.     return -1;

  1496. }

  1497. 

  1498. // -------------------------------------------------------------------------------------------------------------------

  1499. 

  1500. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1501. {

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

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

  1504. 

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

  1506.     {

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

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

  1509. 

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

  1511.         return 0.0f;

  1512.     }

  1513. 

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

  1515.     return 0.0f;

  1516. }

  1517. 

  1518. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1519. {

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

  1521. 

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

  1523.     {

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

  1525.             return plugin->getParameterValue(parameterId);

  1526. 

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

  1528.         return 0.0f;

  1529.     }

  1530. 

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

  1532.     return 0.0f;

  1533. }

  1534. 

  1535. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1536. {

  1537. #ifdef BUILD_BRIDGE

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

  1539. #else

  1540.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, (parameterId == CB::PARAMETER_CTRL_CHANNEL) ? -1.0f : 0.0f);

  1541. #endif

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

  1543. 

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

  1545.         return plugin->getInternalParameterValue(parameterId);

  1546. 

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

  1548.     return 0.0f;

  1549. }

  1550. 

  1551. // -------------------------------------------------------------------------------------------------------------------

  1552. 

  1553. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1554. {

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

  1556. 

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

  1558. }

  1559. 

  1560. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1561. {

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

  1563. 

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

  1565. }

  1566. 

  1567. // -------------------------------------------------------------------------------------------------------------------

  1568. 

  1569. void carla_set_active(uint pluginId, bool onOff)

  1570. {

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

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

  1573. 

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

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

  1576. 

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

  1578. }

  1579. 

  1580. #ifndef BUILD_BRIDGE

  1581. void carla_set_drywet(uint pluginId, float value)

  1582. {

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

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

  1585. 

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

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

  1588. 

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

  1590. }

  1591. 

  1592. void carla_set_volume(uint pluginId, float value)

  1593. {

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

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

  1596. 

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

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

  1599. 

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

  1601. }

  1602. 

  1603. void carla_set_balance_left(uint pluginId, float value)

  1604. {

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

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

  1607. 

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

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

  1610. 

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

  1612. }

  1613. 

  1614. void carla_set_balance_right(uint pluginId, float value)

  1615. {

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

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

  1618. 

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

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

  1621. 

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

  1623. }

  1624. 

  1625. void carla_set_panning(uint pluginId, float value)

  1626. {

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

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

  1629. 

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

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

  1632. 

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

  1634. }

  1635. 

  1636. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1637. {

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

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

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

  1641. 

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

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

  1644. 

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

  1646. }

  1647. 

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

  1649. {

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

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

  1652. 

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

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

  1655. 

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

  1657. }

  1658. #endif

  1659. 

  1660. // -------------------------------------------------------------------------------------------------------------------

  1661. 

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

  1663. {

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

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

  1666. 

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

  1668.     {

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

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

  1671. 

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

  1673.         return;

  1674.     }

  1675. 

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

  1677. }

  1678. 

  1679. #ifndef BUILD_BRIDGE

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

  1681. {

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

  1683.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  1685. 

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

  1687.     {

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

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

  1690. 

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

  1692.         return;

  1693.     }

  1694. 

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

  1696. }

  1697. 

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

  1699. {

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

  1701.     CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < MAX_MIDI_CONTROL,);

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

  1703. 

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

  1705.     {

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

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

  1708. 

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

  1710.         return;

  1711.     }

  1712. 

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

  1714. }

  1715. #endif

  1716. 

  1717. // -------------------------------------------------------------------------------------------------------------------

  1718. 

  1719. void carla_set_program(uint pluginId, uint32_t programId)

  1720. {

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

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

  1723. 

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

  1725.     {

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

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

  1728. 

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

  1730.         return;

  1731.     }

  1732. 

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

  1734. }

  1735. 

  1736. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1737. {

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

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

  1740. 

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

  1742.     {

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

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

  1745. 

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

  1747.         return;

  1748.     }

  1749. 

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

  1751. }

  1752. 

  1753. // -------------------------------------------------------------------------------------------------------------------

  1754. 

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

  1756. {

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

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

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

  1760.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1762. 

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

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

  1765. 

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

  1767. }

  1768. 

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

  1770. {

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

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

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

  1774. 

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

  1776.     {

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

  1778.         {

  1779.             std::vector<uint8_t> chunk(carla_getChunkFromBase64String(chunkData));

  1780.             return plugin->setChunkData(chunk.data(), chunk.size());

  1781.         }

  1782. 

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

  1784.         return;

  1785.     }

  1786. 

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

  1788. }

  1789. 

  1790. // -------------------------------------------------------------------------------------------------------------------

  1791. 

  1792. void carla_prepare_for_save(uint pluginId)

  1793. {

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

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

  1796. 

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

  1798.         return plugin->prepareForSave();

  1799. 

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

  1801. }

  1802. 

  1803. void carla_reset_parameters(uint pluginId)

  1804. {

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

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

  1807. 

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

  1809.         return plugin->resetParameters();

  1810. 

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

  1812. }

  1813. 

  1814. void carla_randomize_parameters(uint pluginId)

  1815. {

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

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

  1818. 

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

  1820.         return plugin->randomizeParameters();

  1821. 

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

  1823. }

  1824. 

  1825. #ifndef BUILD_BRIDGE

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

  1827. {

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

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

  1830. 

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

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

  1833. 

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

  1835. }

  1836. #endif

  1837. 

  1838. void carla_show_custom_ui(uint pluginId, bool yesNo)

  1839. {

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

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

  1842. 

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

  1844.         return plugin->showCustomUI(yesNo);

  1845. 

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

  1847. }

  1848. 

  1849. // -------------------------------------------------------------------------------------------------------------------

  1850. 

  1851. uint32_t carla_get_buffer_size()

  1852. {

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

  1854.     carla_debug("carla_get_buffer_size()");

  1855. 

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

  1857. }

  1858. 

  1859. double carla_get_sample_rate()

  1860. {

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

  1862.     carla_debug("carla_get_sample_rate()");

  1863. 

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

  1865. }

  1866. 

  1867. // -------------------------------------------------------------------------------------------------------------------

  1868. 

  1869. const char* carla_get_last_error()

  1870. {

  1871.     carla_debug("carla_get_last_error()");

  1872. 

  1873.     if (gStandalone.engine != nullptr)

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

  1875. 

  1876.     return gStandalone.lastError;

  1877. }

  1878. 

  1879. const char* carla_get_host_osc_url_tcp()

  1880. {

  1881.     carla_debug("carla_get_host_osc_url_tcp()");

  1882. 

  1883. #ifdef HAVE_LIBLO

  1884.     if (gStandalone.engine == nullptr)

  1885.     {

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

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

  1888.         return nullptr;

  1889.     }

  1890. 

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

  1892. #else

  1893.     return nullptr;

  1894. #endif

  1895. }

  1896. 

  1897. const char* carla_get_host_osc_url_udp()

  1898. {

  1899.     carla_debug("carla_get_host_osc_url_udp()");

  1900. 

  1901. #ifdef HAVE_LIBLO

  1902.     if (gStandalone.engine == nullptr)

  1903.     {

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

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

  1906.         return nullptr;

  1907.     }

  1908. 

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

  1910. #else

  1911.     return nullptr;

  1912. #endif

  1913. }

  1914. 

  1915. // -------------------------------------------------------------------------------------------------------------------

  1916. 

  1917. #include "CarlaPluginUI.cpp"

  1918. #include "CarlaDssiUtils.cpp"

  1919. #include "CarlaPatchbayUtils.cpp"

  1920. #include "CarlaPipeUtils.cpp"

  1921. #include "CarlaStateUtils.cpp"

  1922. #include "CarlaJuceEvents.cpp"

  1923. 

  1924. // -------------------------------------------------------------------------------------------------------------------