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

2257 lines
80KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

  3.  * Copyright (C) 2011-2019 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. #include "ThreadSafeFFTW.hpp"

  30. 

  31. #ifdef BUILD_BRIDGE

  32. # include "water/files/File.h"

  33. #else

  34. # include "CarlaLogThread.hpp"

  35. #endif

  36. 

  37. #ifdef USING_JUCE

  38. # if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  39. #  pragma GCC diagnostic push

  40. #  pragma GCC diagnostic ignored "-Wconversion"

  41. #  pragma GCC diagnostic ignored "-Weffc++"

  42. #  pragma GCC diagnostic ignored "-Wsign-conversion"

  43. #  pragma GCC diagnostic ignored "-Wundef"

  44. # endif

  45. 

  46. # include "AppConfig.h"

  47. # include "juce_events/juce_events.h"

  48. 

  49. # if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  50. #  pragma GCC diagnostic pop

  51. # endif

  52. #endif

  53. 

  54. #define CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(cond, msg, ret) \

  55.     if (! (cond)) {                                              \

  56.         carla_stderr2("%s: " msg, __FUNCTION__);                 \

  57.         gStandalone.lastError = msg;                             \

  58.         return ret;                                              \

  59.     }

  60. 

  61. namespace CB = CarlaBackend;

  62. using CB::EngineOptions;

  63. 

  64. // --------------------------------------------------------------------------------------------------------------------

  65. // Single, standalone engine

  66. 

  67. struct CarlaBackendStandalone {

  68.     CarlaEngine*       engine;

  69.     EngineCallbackFunc engineCallback;

  70.     void*              engineCallbackPtr;

  71. #ifndef BUILD_BRIDGE

  72.     EngineOptions      engineOptions;

  73.     CarlaLogThread     logThread;

  74.     bool               logThreadEnabled;

  75. #endif

  76. 

  77.     FileCallbackFunc fileCallback;

  78.     void*            fileCallbackPtr;

  79. 

  80.     CarlaString lastError;

  81. 

  82.     CarlaBackendStandalone() noexcept

  83.         : engine(nullptr),

  84.           engineCallback(nullptr),

  85.           engineCallbackPtr(nullptr),

  86. #ifndef BUILD_BRIDGE

  87.           engineOptions(),

  88.           logThread(),

  89.           logThreadEnabled(false),

  90. #endif

  91.           fileCallback(nullptr),

  92.           fileCallbackPtr(nullptr),

  93.           lastError() {}

  94. 

  95.     ~CarlaBackendStandalone() noexcept

  96.     {

  97.         CARLA_SAFE_ASSERT(engine == nullptr);

  98.     }

  99. 

  100.     CARLA_PREVENT_HEAP_ALLOCATION

  101.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  102. };

  103. 

  104. CarlaBackendStandalone gStandalone;

  105. 

  106. #ifdef CARLA_OS_UNIX

  107. static ThreadSafeFFTW sThreadSafeFFTW;

  108. #endif

  109. 

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

  111. // API

  112. 

  113. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  114. #include "CarlaHostCommon.cpp"

  115. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  116. 

  117. // --------------------------------------------------------------------------------------------------------------------

  118. 

  119. uint carla_get_engine_driver_count()

  120. {

  121.     carla_debug("carla_get_engine_driver_count()");

  122. 

  123.     return CarlaEngine::getDriverCount();

  124. }

  125. 

  126. const char* carla_get_engine_driver_name(uint index)

  127. {

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

  129. 

  130.     return CarlaEngine::getDriverName(index);

  131. }

  132. 

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

  134. {

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

  136. 

  137.     return CarlaEngine::getDriverDeviceNames(index);

  138. }

  139. 

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

  141. {

  142.     CARLA_SAFE_ASSERT_RETURN(name != nullptr, nullptr);

  143. 

  144.     static EngineDriverDeviceInfo retDevInfo;

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

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

  147. 

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

  149. 

  150.     if (const EngineDriverDeviceInfo* const devInfo = CarlaEngine::getDriverDeviceInfo(index, name))

  151.     {

  152.         retDevInfo.hints       =  devInfo->hints;

  153.         retDevInfo.bufferSizes = (devInfo->bufferSizes != nullptr) ? devInfo->bufferSizes : nullBufferSizes;

  154.         retDevInfo.sampleRates = (devInfo->sampleRates != nullptr) ? devInfo->sampleRates : nullSampleRates;

  155.     }

  156.     else

  157.     {

  158.         retDevInfo.hints       = 0x0;

  159.         retDevInfo.bufferSizes = nullBufferSizes;

  160.         retDevInfo.sampleRates = nullSampleRates;

  161.     }

  162. 

  163.     return &retDevInfo;

  164. }

  165. 

  166. bool carla_show_engine_driver_device_control_panel(uint index, const char* name)

  167. {

  168.     return CarlaEngine::showDriverDeviceControlPanel(index, name);

  169. }

  170. 

  171. // --------------------------------------------------------------------------------------------------------------------

  172. 

  173. CarlaEngine* carla_get_engine()

  174. {

  175.     carla_debug("carla_get_engine()");

  176. 

  177.     return gStandalone.engine;

  178. }

  179. 

  180. // --------------------------------------------------------------------------------------------------------------------

  181. 

  182. static void carla_engine_init_common(CarlaEngine* const engine)

  183. {

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

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

  186. 

  187.     using water::File;

  188.     const File waterBinaryDir(File::getSpecialLocation(File::currentExecutableFile).getParentDirectory());

  189. 

  190. #ifdef BUILD_BRIDGE

  191.     /*

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

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

  194. 

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

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

  197. 

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

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

  200.     */

  201. 

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

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

  204. 

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

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

  207. 

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

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

  210. 

  211.     if (const char* const pathAudio = std::getenv("ENGINE_OPTION_FILE_PATH_AUDIO"))

  212.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_AUDIO, pathAudio);

  213. 

  214.     if (const char* const pathMIDI = std::getenv("ENGINE_OPTION_FILE_PATH_MIDI"))

  215.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_MIDI, pathMIDI);

  216. 

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

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

  219. 

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

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

  222. 

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

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

  225. 

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

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

  228. 

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

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

  231. 

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

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

  234. 

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

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

  237. 

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

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

  240.     else

  241.         engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES,   0, waterBinaryDir.getFullPathName().toRawUTF8());

  242. 

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

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

  245.     else

  246.         engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES,  0, waterBinaryDir.getChildFile("resources").getFullPathName().toRawUTF8());

  247. 

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

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

  250. 

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

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

  253. #else

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

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

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

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

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

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

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

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

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

  263. 

  264.     if (gStandalone.engineOptions.audioDriver != nullptr)

  265.         engine->setOption(CB::ENGINE_OPTION_AUDIO_DRIVER,      0, gStandalone.engineOptions.audioDriver);

  266. 

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

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

  269. 

  270.     engine->setOption(CB::ENGINE_OPTION_OSC_ENABLED,  gStandalone.engineOptions.oscEnabled, nullptr);

  271.     engine->setOption(CB::ENGINE_OPTION_OSC_PORT_TCP, gStandalone.engineOptions.oscPortTCP, nullptr);

  272.     engine->setOption(CB::ENGINE_OPTION_OSC_PORT_UDP, gStandalone.engineOptions.oscPortUDP, nullptr);

  273. 

  274.     if (gStandalone.engineOptions.pathAudio != nullptr)

  275.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_AUDIO, gStandalone.engineOptions.pathAudio);

  276. 

  277.     if (gStandalone.engineOptions.pathMIDI != nullptr)

  278.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_MIDI, gStandalone.engineOptions.pathMIDI);

  279. 

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

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

  282. 

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

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

  285. 

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

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

  288. 

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

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

  291. 

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

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

  294. 

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

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

  297. 

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

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

  300. 

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

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

  303.     else

  304.         engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES, 0, waterBinaryDir.getFullPathName().toRawUTF8());

  305. 

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

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

  308. 

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

  310. 

  311.     engine->setOption(CB::ENGINE_OPTION_FRONTEND_UI_SCALE, static_cast<int>(gStandalone.engineOptions.uiScale * 1000.0f), nullptr);

  312. 

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

  314.     {

  315.         char strBuf[STR_MAX+1];

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

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

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

  319.     }

  320.     else

  321.     {

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

  323.     }

  324. 

  325. # ifndef CARLA_OS_WIN

  326.     if (gStandalone.engineOptions.wine.executable != nullptr && gStandalone.engineOptions.wine.executable[0] != '\0')

  327.         engine->setOption(CB::ENGINE_OPTION_WINE_EXECUTABLE, 0, gStandalone.engineOptions.wine.executable);

  328. 

  329.     engine->setOption(CB::ENGINE_OPTION_WINE_AUTO_PREFIX, gStandalone.engineOptions.wine.autoPrefix ? 1 : 0, nullptr);

  330. 

  331.     if (gStandalone.engineOptions.wine.fallbackPrefix != nullptr && gStandalone.engineOptions.wine.fallbackPrefix[0] != '\0')

  332.         engine->setOption(CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX, 0, gStandalone.engineOptions.wine.fallbackPrefix);

  333. 

  334.     engine->setOption(CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED, gStandalone.engineOptions.wine.rtPrio ? 1 : 0, nullptr);

  335.     engine->setOption(CB::ENGINE_OPTION_WINE_BASE_RT_PRIO, gStandalone.engineOptions.wine.baseRtPrio, nullptr);

  336.     engine->setOption(CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO, gStandalone.engineOptions.wine.serverRtPrio, nullptr);

  337. # endif

  338. #endif

  339. }

  340. 

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

  342. {

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

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

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

  346. 

  347.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine == nullptr, "Engine is already initialized", false);

  348. 

  349. #ifdef CARLA_OS_WIN

  350.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  351. #endif

  352. 

  353. #ifdef USING_JUCE

  354.     juce::initialiseJuce_GUI();

  355. #endif

  356. 

  357.     CarlaEngine* const engine = CarlaEngine::newDriverByName(driverName);

  358.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(engine != nullptr, "The selected audio driver is not available", false);

  359. 

  360.     gStandalone.engine = engine;

  361. 

  362. #ifdef BUILD_BRIDGE

  363.     if (std::getenv("CARLA_BRIDGE_DUMMY") != nullptr)

  364.     {

  365.         // engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,      CB::ENGINE_PROCESS_MODE_PATCHBAY,         nullptr);

  366.         engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,      CB::ENGINE_PROCESS_MODE_CONTINUOUS_RACK,  nullptr);

  367.         engine->setOption(CB::ENGINE_OPTION_TRANSPORT_MODE,    CB::ENGINE_TRANSPORT_MODE_INTERNAL,       nullptr);

  368. 

  369.         engine->setOption(CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE, 4096, nullptr);

  370.         engine->setOption(CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE, 48000, nullptr);

  371.     }

  372.     else

  373.     {

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

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

  376.     }

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

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

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

  380. #else

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

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

  383. #endif

  384. 

  385.     carla_engine_init_common(engine);

  386. 

  387.     if (engine->init(clientName))

  388.     {

  389. #ifndef BUILD_BRIDGE

  390.         if (gStandalone.logThreadEnabled && std::getenv("CARLA_LOGS_DISABLED") == nullptr)

  391.             gStandalone.logThread.init();

  392. #endif

  393. #ifdef CARLA_OS_UNIX

  394.         sThreadSafeFFTW.init();

  395. #endif

  396.         gStandalone.lastError = "No error";

  397.         return true;

  398.     }

  399.     else

  400.     {

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

  402.         gStandalone.engine = nullptr;

  403.         delete engine;

  404. #ifdef USING_JUCE

  405.         juce::shutdownJuce_GUI();

  406. #endif

  407.         return false;

  408.     }

  409. }

  410. 

  411. #ifdef BUILD_BRIDGE

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

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

  414. {

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

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

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

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

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

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

  421. 

  422.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine == nullptr, "Engine is already initialized", false);

  423. 

  424.     CarlaScopedPointer<CarlaEngine> engine(CarlaEngine::newBridge(audioBaseName,

  425.                                                                   rtClientBaseName,

  426.                                                                   nonRtClientBaseName,

  427.                                                                   nonRtServerBaseName));

  428. 

  429.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(engine != nullptr, "The selected audio driver is not available", false);

  430. 

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

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

  433. 

  434.     carla_engine_init_common(engine);

  435. 

  436.     if (engine->init(clientName))

  437.     {

  438.         gStandalone.lastError = "No error";

  439.         gStandalone.engine = engine.release();

  440.         return true;

  441.     }

  442.     else

  443.     {

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

  445.         return false;

  446.     }

  447. }

  448. #endif

  449. 

  450. bool carla_engine_close()

  451. {

  452.     carla_debug("carla_engine_close()");

  453. 

  454.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  455. 

  456. #ifdef CARLA_OS_UNIX

  457.     const ThreadSafeFFTW::Deinitializer tsfftwde(sThreadSafeFFTW);

  458. #endif

  459. 

  460.     CarlaEngine* const engine = gStandalone.engine;

  461. 

  462.     engine->setAboutToClose();

  463.     engine->removeAllPlugins();

  464. 

  465.     const bool closed = engine->close();

  466. 

  467.     if (! closed)

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

  469. 

  470. #ifndef BUILD_BRIDGE

  471.     gStandalone.logThread.stop();

  472. #endif

  473. 

  474.     gStandalone.engine = nullptr;

  475.     delete engine;

  476. 

  477. #ifdef USING_JUCE

  478.     juce::shutdownJuce_GUI();

  479. #endif

  480.     return closed;

  481. }

  482. 

  483. void carla_engine_idle()

  484. {

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

  486. 

  487.     gStandalone.engine->idle();

  488. 

  489. #if defined(USING_JUCE) && !(defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN))

  490.     const juce::MessageManager* const msgMgr(juce::MessageManager::getInstanceWithoutCreating());

  491.     CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  492. 

  493.     for (; msgMgr->dispatchNextMessageOnSystemQueue(true);) {}

  494. #endif

  495. }

  496. 

  497. bool carla_is_engine_running()

  498. {

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

  500. }

  501. 

  502. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info()

  503. {

  504.     static CarlaRuntimeEngineInfo retInfo;

  505. 

  506.     // reset

  507.     retInfo.load = 0.0f;

  508.     retInfo.xruns = 0;

  509. 

  510.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  511. 

  512.     retInfo.load = gStandalone.engine->getDSPLoad();

  513.     retInfo.xruns = gStandalone.engine->getTotalXruns();

  514. 

  515.     return &retInfo;

  516. }

  517. 

  518. #ifndef BUILD_BRIDGE

  519. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info()

  520. {

  521.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  522. 

  523.     // reset

  524.     retInfo.name = gNullCharPtr;

  525.     retInfo.hints = 0x0;

  526.     retInfo.bufferSize = 0;

  527.     retInfo.bufferSizes = nullptr;

  528.     retInfo.sampleRate = 0.0;

  529.     retInfo.sampleRates = nullptr;

  530. 

  531.     const char* audioDriver;

  532.     const char* audioDevice;

  533. 

  534.     if (CarlaEngine* const engine = gStandalone.engine)

  535.     {

  536.         audioDriver = engine->getCurrentDriverName();

  537.         audioDevice = engine->getOptions().audioDevice;

  538. 

  539.         retInfo.bufferSize = engine->getBufferSize();

  540.         retInfo.sampleRate = engine->getSampleRate();

  541.     }

  542.     else

  543.     {

  544.         audioDriver = gStandalone.engineOptions.audioDriver;

  545.         audioDevice = gStandalone.engineOptions.audioDevice;

  546. 

  547.         retInfo.bufferSize = gStandalone.engineOptions.audioBufferSize;

  548.         retInfo.sampleRate = gStandalone.engineOptions.audioSampleRate;

  549.     }

  550.     CARLA_SAFE_ASSERT_RETURN(audioDriver != nullptr, &retInfo);

  551.     CARLA_SAFE_ASSERT_RETURN(audioDevice != nullptr, &retInfo);

  552. 

  553.     uint index = 0;

  554.     uint count = CarlaEngine::getDriverCount();

  555.     for (; index<count; ++index)

  556.     {

  557.         const char* const testDriverName = CarlaEngine::getDriverName(index);

  558.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  559. 

  560.         if (std::strcmp(testDriverName, audioDriver) == 0)

  561.             break;

  562.     }

  563.     CARLA_SAFE_ASSERT_RETURN(index != count, &retInfo);

  564. 

  565.     const EngineDriverDeviceInfo* const devInfo = CarlaEngine::getDriverDeviceInfo(index, audioDevice);

  566.     CARLA_SAFE_ASSERT_RETURN(devInfo != nullptr, &retInfo);

  567. 

  568.     retInfo.name        = audioDevice;

  569.     retInfo.hints       = devInfo->hints;

  570.     retInfo.bufferSizes = devInfo->bufferSizes;

  571.     retInfo.sampleRates = devInfo->sampleRates;

  572. 

  573.     return &retInfo;

  574. }

  575. 

  576. bool carla_set_engine_buffer_size_and_sample_rate(uint bufferSize, double sampleRate)

  577. {

  578.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, false);

  579.     carla_debug("carla_set_engine_buffer_size_and_sample_rate(%u, %f)", bufferSize, sampleRate);

  580. 

  581.     return gStandalone.engine->setBufferSizeAndSampleRate(bufferSize, sampleRate);

  582. }

  583. 

  584. bool carla_show_engine_device_control_panel()

  585. {

  586.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, false);

  587.     carla_debug("carla_show_engine_device_control_panel()");

  588. 

  589.     return gStandalone.engine->showDeviceControlPanel();

  590. }

  591. #endif

  592. 

  593. void carla_clear_engine_xruns()

  594. {

  595.     if (gStandalone.engine != nullptr)

  596.         gStandalone.engine->clearXruns();

  597. }

  598. 

  599. void carla_cancel_engine_action()

  600. {

  601.     if (gStandalone.engine != nullptr)

  602.         gStandalone.engine->setActionCanceled(true);

  603. }

  604. 

  605. bool carla_set_engine_about_to_close()

  606. {

  607.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, true);

  608.     carla_debug("carla_set_engine_about_to_close()");

  609. 

  610.     return gStandalone.engine->setAboutToClose();

  611. }

  612. 

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

  614. {

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

  616. 

  617.     gStandalone.engineCallback    = func;

  618.     gStandalone.engineCallbackPtr = ptr;

  619. 

  620. #ifndef BUILD_BRIDGE

  621.     gStandalone.logThread.setCallback(func, ptr);

  622. #endif

  623. 

  624.     if (gStandalone.engine != nullptr)

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

  626. }

  627. 

  628. #ifndef BUILD_BRIDGE

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

  630. {

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

  632. 

  633.     switch (option)

  634.     {

  635.     case CB::ENGINE_OPTION_DEBUG:

  636.         break;

  637. 

  638.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  641.         break;

  642. 

  643.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

  644.         CARLA_SAFE_ASSERT_RETURN(value >= CB::ENGINE_TRANSPORT_MODE_DISABLED && value <= CB::ENGINE_TRANSPORT_MODE_BRIDGE,);

  645. 

  646.         // jack transport cannot be disabled in multi-client

  647.         if (gStandalone.engineOptions.processMode == CB::ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS

  648.             && value != CB::ENGINE_TRANSPORT_MODE_JACK)

  649.         {

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

  651. 

  652.             if (gStandalone.engineCallback != nullptr)

  653.                 gStandalone.engineCallback(gStandalone.engineCallbackPtr,

  654.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  655.                                            0,

  656.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  657.                                            0, 0, 0.0f,

  658.                                            gStandalone.engineOptions.transportExtra);

  659.         }

  660.         else

  661.         {

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

  663.         }

  664. 

  665.         delete[] gStandalone.engineOptions.transportExtra;

  666.         if (value != CB::ENGINE_TRANSPORT_MODE_DISABLED && valueStr != nullptr)

  667.             gStandalone.engineOptions.transportExtra = carla_strdup_safe(valueStr);

  668.         else

  669.             gStandalone.engineOptions.transportExtra = nullptr;

  670.         break;

  671. 

  672.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  675.         break;

  676. 

  677.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  680.         break;

  681. 

  682.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  685.         break;

  686. 

  687.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  690.         break;

  691. 

  692.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  693.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  695.         break;

  696. 

  697.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  698.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  700.         break;

  701. 

  702.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  703.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  705.         break;

  706. 

  707.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  708.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  710.         break;

  711. 

  712.     case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

  714.         gStandalone.engineOptions.audioTripleBuffer = (value != 0);

  715.         break;

  716. 

  717.     case CB::ENGINE_OPTION_AUDIO_DRIVER:

  718.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  719. 

  720.         if (gStandalone.engineOptions.audioDriver != nullptr)

  721.             delete[] gStandalone.engineOptions.audioDriver;

  722. 

  723.         gStandalone.engineOptions.audioDriver = carla_strdup_safe(valueStr);

  724.         break;

  725. 

  726.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  727.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  728. 

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

  730.             delete[] gStandalone.engineOptions.audioDevice;

  731. 

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

  733.         break;

  734. 

  735.     case CB::ENGINE_OPTION_OSC_ENABLED:

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

  737.         gStandalone.engineOptions.oscEnabled = (value != 0);

  738.         break;

  739. 

  740.     case CB::ENGINE_OPTION_OSC_PORT_TCP:

  741.         CARLA_SAFE_ASSERT_RETURN(value <= 0 || value >= 1024,);

  742.         gStandalone.engineOptions.oscPortTCP = value;

  743.         break;

  744. 

  745.     case CB::ENGINE_OPTION_OSC_PORT_UDP:

  746.         CARLA_SAFE_ASSERT_RETURN(value <= 0 || value >= 1024,);

  747.         gStandalone.engineOptions.oscPortUDP = value;

  748.         break;

  749. 

  750.     case CB::ENGINE_OPTION_FILE_PATH:

  751.         CARLA_SAFE_ASSERT_RETURN(value > CB::FILE_NONE,);

  752.         CARLA_SAFE_ASSERT_RETURN(value <= CB::FILE_MIDI,);

  753.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  754. 

  755.         switch (value)

  756.         {

  757.         case CB::FILE_AUDIO:

  758.             if (gStandalone.engineOptions.pathAudio != nullptr)

  759.                 delete[] gStandalone.engineOptions.pathAudio;

  760.             gStandalone.engineOptions.pathAudio = carla_strdup_safe(valueStr);

  761.             break;

  762.         case CB::FILE_MIDI:

  763.             if (gStandalone.engineOptions.pathMIDI != nullptr)

  764.                 delete[] gStandalone.engineOptions.pathMIDI;

  765.             gStandalone.engineOptions.pathMIDI = carla_strdup_safe(valueStr);

  766.             break;

  767.         }

  768.         break;

  769. 

  770.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  773.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  774. 

  775.         switch (value)

  776.         {

  777.         case CB::PLUGIN_LADSPA:

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

  779.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  781.             break;

  782.         case CB::PLUGIN_DSSI:

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

  784.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  786.             break;

  787.         case CB::PLUGIN_LV2:

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

  789.                 delete[] gStandalone.engineOptions.pathLV2;

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

  791.             break;

  792.         case CB::PLUGIN_VST2:

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

  794.                 delete[] gStandalone.engineOptions.pathVST2;

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

  796.             break;

  797.         case CB::PLUGIN_VST3:

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

  799.                 delete[] gStandalone.engineOptions.pathVST3;

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

  801.             break;

  802.         case CB::PLUGIN_SF2:

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

  804.                 delete[] gStandalone.engineOptions.pathSF2;

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

  806.             break;

  807.         case CB::PLUGIN_SFZ:

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

  809.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  811.             break;

  812.         }

  813.         break;

  814. 

  815.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  817. 

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

  819.             delete[] gStandalone.engineOptions.binaryDir;

  820. 

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

  822.         break;

  823. 

  824.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  826. 

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

  828.             delete[] gStandalone.engineOptions.resourceDir;

  829. 

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

  831.         break;

  832. 

  833.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  836.         break;

  837. 

  838.     case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  839.         CARLA_SAFE_ASSERT_RETURN(value > 0,);

  840.         gStandalone.engineOptions.uiScale = static_cast<float>(value) / 1000;

  841.         break;

  842. 

  843.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  846.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  848.     }   break;

  849. 

  850. #ifndef CARLA_OS_WIN

  851.     case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  853. 

  854.         if (gStandalone.engineOptions.wine.executable != nullptr)

  855.             delete[] gStandalone.engineOptions.wine.executable;

  856. 

  857.         gStandalone.engineOptions.wine.executable = carla_strdup_safe(valueStr);

  858.         break;

  859. 

  860.     case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

  862.         gStandalone.engineOptions.wine.autoPrefix = (value != 0);

  863.         break;

  864. 

  865.     case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  867. 

  868.         if (gStandalone.engineOptions.wine.fallbackPrefix != nullptr)

  869.             delete[] gStandalone.engineOptions.wine.fallbackPrefix;

  870. 

  871.         gStandalone.engineOptions.wine.fallbackPrefix = carla_strdup_safe(valueStr);

  872.         break;

  873. 

  874.     case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

  876.         gStandalone.engineOptions.wine.rtPrio = (value != 0);

  877.         break;

  878. 

  879.     case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

  880.         CARLA_SAFE_ASSERT_RETURN(value >= 1 && value <= 89,);

  881.         gStandalone.engineOptions.wine.baseRtPrio = value;

  882.         break;

  883. 

  884.     case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

  885.         CARLA_SAFE_ASSERT_RETURN(value >= 1 && value <= 99,);

  886.         gStandalone.engineOptions.wine.serverRtPrio = value;

  887.         break;

  888. #endif

  889. 

  890.     case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  891.         gStandalone.logThreadEnabled = (value != 0);

  892.         break;

  893.     }

  894. 

  895.     if (gStandalone.engine != nullptr)

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

  897. }

  898. #endif

  899. 

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

  901. {

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

  903. 

  904.     gStandalone.fileCallback    = func;

  905.     gStandalone.fileCallbackPtr = ptr;

  906. 

  907.     if (gStandalone.engine != nullptr)

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

  909. }

  910. 

  911. // --------------------------------------------------------------------------------------------------------------------

  912. 

  913. bool carla_load_file(const char* filename)

  914. {

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

  916.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  917. 

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

  919. 

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

  921. }

  922. 

  923. bool carla_load_project(const char* filename)

  924. {

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

  926.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  927. 

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

  929. 

  930.     return gStandalone.engine->loadProject(filename, true);

  931. }

  932. 

  933. bool carla_save_project(const char* filename)

  934. {

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

  936.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  937. 

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

  939. 

  940.     return gStandalone.engine->saveProject(filename, true);

  941. }

  942. 

  943. #ifndef BUILD_BRIDGE

  944. void carla_clear_project_filename()

  945. {

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

  947. 

  948.     carla_debug("carla_clear_project_filename()");

  949. 

  950.     gStandalone.engine->clearCurrentProjectFilename();

  951. }

  952. 

  953. // --------------------------------------------------------------------------------------------------------------------

  954. 

  955. bool carla_patchbay_connect(bool external, uint groupIdA, uint portIdA, uint groupIdB, uint portIdB)

  956. {

  957.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  958. 

  959.     carla_debug("carla_patchbay_connect(%s, %u, %u, %u, %u)",

  960.                 bool2str(external), groupIdA, portIdA, groupIdB, portIdB);

  961. 

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

  963. }

  964. 

  965. bool carla_patchbay_disconnect(bool external, uint connectionId)

  966. {

  967.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  968. 

  969.     carla_debug("carla_patchbay_disconnect(%s, %i)", bool2str(external), connectionId);

  970. 

  971.     return gStandalone.engine->patchbayDisconnect(external, connectionId);

  972. }

  973. 

  974. bool carla_patchbay_refresh(bool external)

  975. {

  976.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  977. 

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

  979. 

  980.     return gStandalone.engine->patchbayRefresh(true, false, external);

  981. }

  982. 

  983. // --------------------------------------------------------------------------------------------------------------------

  984. 

  985. void carla_transport_play()

  986. {

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

  988. 

  989.     carla_debug("carla_transport_play()");

  990. 

  991.     gStandalone.engine->transportPlay();

  992. }

  993. 

  994. void carla_transport_pause()

  995. {

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

  997. 

  998.     carla_debug("carla_transport_pause()");

  999. 

  1000.     gStandalone.engine->transportPause();

  1001. }

  1002. 

  1003. void carla_transport_bpm(double bpm)

  1004. {

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

  1006. 

  1007.     carla_debug("carla_transport_bpm(%f)", bpm);

  1008. 

  1009.     gStandalone.engine->transportBPM(bpm);

  1010. }

  1011. 

  1012. void carla_transport_relocate(uint64_t frame)

  1013. {

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

  1015. 

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

  1017. 

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

  1019. }

  1020. 

  1021. uint64_t carla_get_current_transport_frame()

  1022. {

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

  1024. 

  1025.     return gStandalone.engine->getTimeInfo().frame;

  1026. }

  1027. 

  1028. const CarlaTransportInfo* carla_get_transport_info()

  1029. {

  1030.     static CarlaTransportInfo retTransInfo;

  1031.     retTransInfo.clear();

  1032. 

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

  1034. 

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

  1036. 

  1037.     retTransInfo.playing = timeInfo.playing;

  1038.     retTransInfo.frame   = timeInfo.frame;

  1039. 

  1040.     if (timeInfo.bbt.valid)

  1041.     {

  1042.         retTransInfo.bar  = timeInfo.bbt.bar;

  1043.         retTransInfo.beat = timeInfo.bbt.beat;

  1044.         retTransInfo.tick = static_cast<int32_t>(timeInfo.bbt.tick + 0.5);

  1045.         retTransInfo.bpm  = timeInfo.bbt.beatsPerMinute;

  1046.     }

  1047. 

  1048.     return &retTransInfo;

  1049. }

  1050. #endif

  1051. 

  1052. // --------------------------------------------------------------------------------------------------------------------

  1053. 

  1054. uint32_t carla_get_current_plugin_count()

  1055. {

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

  1057. 

  1058.     carla_debug("carla_get_current_plugin_count()");

  1059. 

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

  1061. }

  1062. 

  1063. uint32_t carla_get_max_plugin_number()

  1064. {

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

  1066. 

  1067.     carla_debug("carla_get_max_plugin_number()");

  1068. 

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

  1070. }

  1071. 

  1072. // --------------------------------------------------------------------------------------------------------------------

  1073. 

  1074. bool carla_add_plugin(BinaryType btype, PluginType ptype,

  1075.                       const char* filename, const char* name, const char* label, int64_t uniqueId,

  1076.                       const void* extraPtr, uint options)

  1077. {

  1078.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1079. 

  1080.     carla_debug("carla_add_plugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p, %u)",

  1081.                 btype, CB::BinaryType2Str(btype),

  1082.                 ptype, CB::PluginType2Str(ptype),

  1083.                 filename, name, label, uniqueId, extraPtr, options);

  1084. 

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

  1086. }

  1087. 

  1088. bool carla_remove_plugin(uint pluginId)

  1089. {

  1090.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1091. 

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

  1093. 

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

  1095. }

  1096. 

  1097. bool carla_remove_all_plugins()

  1098. {

  1099.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1100. 

  1101.     carla_debug("carla_remove_all_plugins()");

  1102. 

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

  1104. }

  1105. 

  1106. #ifndef BUILD_BRIDGE

  1107. bool carla_rename_plugin(uint pluginId, const char* newName)

  1108. {

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

  1110.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1111. 

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

  1113. 

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

  1115. }

  1116. 

  1117. bool carla_clone_plugin(uint pluginId)

  1118. {

  1119.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1120. 

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

  1122. 

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

  1124. }

  1125. 

  1126. bool carla_replace_plugin(uint pluginId)

  1127. {

  1128.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1129. 

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

  1131. 

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

  1133. }

  1134. 

  1135. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1136. {

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

  1138.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1139. 

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

  1141. 

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

  1143. }

  1144. #endif

  1145. 

  1146. // --------------------------------------------------------------------------------------------------------------------

  1147. 

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

  1149. {

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

  1151.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr

  1152.                                           && gStandalone.engine->isRunning(), "Engine is not running", false);

  1153. 

  1154.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1155.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(plugin != nullptr, "could not find requested plugin", false);

  1156. 

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

  1158. 

  1159.     return plugin->loadStateFromFile(filename);

  1160. }

  1161. 

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

  1163. {

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

  1165.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1166. 

  1167.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1168.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(plugin != nullptr, "could not find requested plugin", false);

  1169. 

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

  1171. 

  1172.     return plugin->saveStateToFile(filename);

  1173. }

  1174. 

  1175. bool carla_export_plugin_lv2(uint pluginId, const char* lv2path)

  1176. {

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

  1178.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1179. 

  1180.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1181.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(plugin != nullptr, "could not find requested plugin", false);

  1182. 

  1183.     carla_debug("carla_export_plugin_lv2(%i, \"%s\")", pluginId, lv2path);

  1184. 

  1185.     return plugin->exportAsLV2(lv2path);

  1186. }

  1187. 

  1188. // --------------------------------------------------------------------------------------------------------------------

  1189. 

  1190. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1191. {

  1192.     static CarlaPluginInfo retInfo;

  1193. 

  1194.     // reset

  1195.     retInfo.type             = CB::PLUGIN_NONE;

  1196.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1197.     retInfo.hints            = 0x0;

  1198.     retInfo.optionsAvailable = 0x0;

  1199.     retInfo.optionsEnabled   = 0x0;

  1200.     retInfo.filename         = gNullCharPtr;

  1201.     retInfo.name             = gNullCharPtr;

  1202.     retInfo.iconName         = gNullCharPtr;

  1203.     retInfo.uniqueId         = 0;

  1204. 

  1205.     // cleanup

  1206.     if (retInfo.label != gNullCharPtr)

  1207.     {

  1208.         delete[] retInfo.label;

  1209.         retInfo.label = gNullCharPtr;

  1210.     }

  1211. 

  1212.     if (retInfo.maker != gNullCharPtr)

  1213.     {

  1214.         delete[] retInfo.maker;

  1215.         retInfo.maker = gNullCharPtr;

  1216.     }

  1217. 

  1218.     if (retInfo.copyright != gNullCharPtr)

  1219.     {

  1220.         delete[] retInfo.copyright;

  1221.         retInfo.copyright = gNullCharPtr;

  1222.     }

  1223. 

  1224.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1225. 

  1226.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1227.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1228. 

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

  1230. 

  1231.     char strBuf[STR_MAX+1];

  1232.     carla_zeroChars(strBuf, STR_MAX+1);

  1233. 

  1234.     retInfo.type     = plugin->getType();

  1235.     retInfo.category = plugin->getCategory();

  1236.     retInfo.hints    = plugin->getHints();

  1237.     retInfo.filename = plugin->getFilename();

  1238.     retInfo.name     = plugin->getName();

  1239.     retInfo.iconName = plugin->getIconName();

  1240.     retInfo.uniqueId = plugin->getUniqueId();

  1241. 

  1242.     retInfo.optionsAvailable = plugin->getOptionsAvailable();

  1243.     retInfo.optionsEnabled   = plugin->getOptionsEnabled();

  1244. 

  1245.     if (plugin->getLabel(strBuf))

  1246.         retInfo.label = carla_strdup_safe(strBuf);

  1247.     if (plugin->getMaker(strBuf))

  1248.         retInfo.maker = carla_strdup_safe(strBuf);

  1249.     if (plugin->getCopyright(strBuf))

  1250.         retInfo.copyright = carla_strdup_safe(strBuf);

  1251. 

  1252.     checkStringPtr(retInfo.filename);

  1253.     checkStringPtr(retInfo.name);

  1254.     checkStringPtr(retInfo.iconName);

  1255.     checkStringPtr(retInfo.label);

  1256.     checkStringPtr(retInfo.maker);

  1257.     checkStringPtr(retInfo.copyright);

  1258. 

  1259.     return &retInfo;

  1260. }

  1261. 

  1262. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1263. {

  1264.     static CarlaPortCountInfo retInfo;

  1265.     carla_zeroStruct(retInfo);

  1266. 

  1267.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1268. 

  1269.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1270.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1271. 

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

  1273. 

  1274.     retInfo.ins   = plugin->getAudioInCount();

  1275.     retInfo.outs  = plugin->getAudioOutCount();

  1276.     return &retInfo;

  1277. }

  1278. 

  1279. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1280. {

  1281.     static CarlaPortCountInfo retInfo;

  1282.     carla_zeroStruct(retInfo);

  1283. 

  1284.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1285. 

  1286.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1287.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1288. 

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

  1290. 

  1291.     retInfo.ins   = plugin->getMidiInCount();

  1292.     retInfo.outs  = plugin->getMidiOutCount();

  1293.     return &retInfo;

  1294. }

  1295. 

  1296. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1297. {

  1298.     static CarlaPortCountInfo retInfo;

  1299.     carla_zeroStruct(retInfo);

  1300. 

  1301.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1302. 

  1303.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1304.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1305. 

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

  1307. 

  1308.     plugin->getParameterCountInfo(retInfo.ins, retInfo.outs);

  1309.     return &retInfo;

  1310. }

  1311. 

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

  1313. {

  1314.     static CarlaParameterInfo retInfo;

  1315. 

  1316.     // reset

  1317.     retInfo.scalePointCount = 0;

  1318. 

  1319.     // cleanup

  1320.     if (retInfo.name != gNullCharPtr)

  1321.     {

  1322.         delete[] retInfo.name;

  1323.         retInfo.name = gNullCharPtr;

  1324.     }

  1325. 

  1326.     if (retInfo.symbol != gNullCharPtr)

  1327.     {

  1328.         delete[] retInfo.symbol;

  1329.         retInfo.symbol = gNullCharPtr;

  1330.     }

  1331. 

  1332.     if (retInfo.unit != gNullCharPtr)

  1333.     {

  1334.         delete[] retInfo.unit;

  1335.         retInfo.unit = gNullCharPtr;

  1336.     }

  1337. 

  1338.     if (retInfo.comment != gNullCharPtr)

  1339.     {

  1340.         delete[] retInfo.comment;

  1341.         retInfo.comment = gNullCharPtr;

  1342.     }

  1343. 

  1344.     if (retInfo.groupName != gNullCharPtr)

  1345.     {

  1346.         delete[] retInfo.groupName;

  1347.         retInfo.groupName = gNullCharPtr;

  1348.     }

  1349. 

  1350.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1351. 

  1352.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1353.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1354. 

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

  1356. 

  1357.     char strBuf[STR_MAX+1];

  1358.     carla_zeroChars(strBuf, STR_MAX+1);

  1359. 

  1360.     retInfo.scalePointCount = plugin->getParameterScalePointCount(parameterId);

  1361. 

  1362.     if (plugin->getParameterName(parameterId, strBuf))

  1363.     {

  1364.         retInfo.name = carla_strdup_safe(strBuf);

  1365.         carla_zeroChars(strBuf, STR_MAX+1);

  1366.     }

  1367. 

  1368.     if (plugin->getParameterSymbol(parameterId, strBuf))

  1369.     {

  1370.         retInfo.symbol = carla_strdup_safe(strBuf);

  1371.         carla_zeroChars(strBuf, STR_MAX+1);

  1372.     }

  1373. 

  1374.     if (plugin->getParameterUnit(parameterId, strBuf))

  1375.     {

  1376.         retInfo.unit = carla_strdup_safe(strBuf);

  1377.         carla_zeroChars(strBuf, STR_MAX+1);

  1378.     }

  1379. 

  1380.     if (plugin->getParameterComment(parameterId, strBuf))

  1381.     {

  1382.         retInfo.comment = carla_strdup_safe(strBuf);

  1383.         carla_zeroChars(strBuf, STR_MAX+1);

  1384.     }

  1385. 

  1386.     if (plugin->getParameterGroupName(parameterId, strBuf))

  1387.     {

  1388.         retInfo.groupName = carla_strdup_safe(strBuf);

  1389.         carla_zeroChars(strBuf, STR_MAX+1);

  1390.     }

  1391. 

  1392.     checkStringPtr(retInfo.name);

  1393.     checkStringPtr(retInfo.symbol);

  1394.     checkStringPtr(retInfo.unit);

  1395.     checkStringPtr(retInfo.comment);

  1396.     checkStringPtr(retInfo.groupName);

  1397. 

  1398.     return &retInfo;

  1399. }

  1400. 

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

  1402. {

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

  1404. 

  1405.     static CarlaScalePointInfo retInfo;

  1406. 

  1407.     // reset

  1408.     retInfo.value = 0.0f;

  1409. 

  1410.     // cleanup

  1411.     if (retInfo.label != gNullCharPtr)

  1412.     {

  1413.         delete[] retInfo.label;

  1414.         retInfo.label = gNullCharPtr;

  1415.     }

  1416. 

  1417.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1418. 

  1419.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1420.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1421. 

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

  1423. 

  1424.     char strBuf[STR_MAX+1];

  1425. 

  1426.     retInfo.value = plugin->getParameterScalePointValue(parameterId, scalePointId);

  1427. 

  1428.     carla_zeroChars(strBuf, STR_MAX+1);

  1429.     if (plugin->getParameterScalePointLabel(parameterId, scalePointId, strBuf))

  1430.         retInfo.label = carla_strdup_safe(strBuf);

  1431. 

  1432.     checkStringPtr(retInfo.label);

  1433. 

  1434.     return &retInfo;

  1435. }

  1436. 

  1437. // --------------------------------------------------------------------------------------------------------------------

  1438. 

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

  1440. {

  1441.     static ParameterData retParamData;

  1442. 

  1443.     // reset

  1444.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1445.     retParamData.hints       = 0x0;

  1446.     retParamData.index       = CB::PARAMETER_NULL;

  1447.     retParamData.rindex      = -1;

  1448.     retParamData.midiChannel = 0;

  1449.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1450.     retParamData.mappedMinimum = 0.0f;

  1451.     retParamData.mappedMaximum = 0.0f;

  1452. 

  1453.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retParamData);

  1454. 

  1455.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1456.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retParamData);

  1457. 

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

  1459.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), &retParamData);

  1460. 

  1461.     const ParameterData& pluginParamData(plugin->getParameterData(parameterId));

  1462.     retParamData.type        = pluginParamData.type;

  1463.     retParamData.hints       = pluginParamData.hints;

  1464.     retParamData.index       = pluginParamData.index;

  1465.     retParamData.rindex      = pluginParamData.rindex;

  1466.     retParamData.midiChannel = pluginParamData.midiChannel;

  1467.     retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1468.     retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1469.     retParamData.mappedMaximum = pluginParamData.mappedMaximum;

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

  1471. }

  1472. 

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

  1474. {

  1475.     static ParameterRanges retParamRanges;

  1476. 

  1477.     // reset

  1478.     retParamRanges.def       = 0.0f;

  1479.     retParamRanges.min       = 0.0f;

  1480.     retParamRanges.max       = 1.0f;

  1481.     retParamRanges.step      = 0.01f;

  1482.     retParamRanges.stepSmall = 0.0001f;

  1483.     retParamRanges.stepLarge = 0.1f;

  1484. 

  1485.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retParamRanges);

  1486. 

  1487.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1488.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retParamRanges);

  1489. 

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

  1491.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), &retParamRanges);

  1492. 

  1493.     const ParameterRanges& pluginParamRanges(plugin->getParameterRanges(parameterId));

  1494.     retParamRanges.def       = pluginParamRanges.def;

  1495.     retParamRanges.min       = pluginParamRanges.min;

  1496.     retParamRanges.max       = pluginParamRanges.max;

  1497.     retParamRanges.step      = pluginParamRanges.step;

  1498.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1499.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1500.     return &pluginParamRanges;

  1501. }

  1502. 

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

  1504. {

  1505.     static MidiProgramData retMidiProgData = { 0, 0, gNullCharPtr };

  1506. 

  1507.     // reset

  1508.     retMidiProgData.bank    = 0;

  1509.     retMidiProgData.program = 0;

  1510. 

  1511.     if (retMidiProgData.name != gNullCharPtr)

  1512.     {

  1513.         delete[] retMidiProgData.name;

  1514.         retMidiProgData.name = gNullCharPtr;

  1515.     }

  1516. 

  1517.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retMidiProgData);

  1518. 

  1519.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1520.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retMidiProgData);

  1521. 

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

  1523.     CARLA_SAFE_ASSERT_RETURN(midiProgramId < plugin->getMidiProgramCount(), &retMidiProgData);

  1524. 

  1525.     const MidiProgramData& pluginMidiProgData(plugin->getMidiProgramData(midiProgramId));

  1526.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1527.     retMidiProgData.program = pluginMidiProgData.program;

  1528. 

  1529.     if (pluginMidiProgData.name != nullptr)

  1530.     {

  1531.         retMidiProgData.name = carla_strdup_safe(pluginMidiProgData.name);

  1532.         checkStringPtr(retMidiProgData.name);

  1533.     }

  1534.     else

  1535.     {

  1536.         retMidiProgData.name = gNullCharPtr;

  1537.     }

  1538. 

  1539.     return &retMidiProgData;

  1540. }

  1541. 

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

  1543. {

  1544.     static CustomData retCustomData = { gNullCharPtr, gNullCharPtr, gNullCharPtr };

  1545. 

  1546.     // reset

  1547.     if (retCustomData.type != gNullCharPtr)

  1548.     {

  1549.         delete[] retCustomData.type;

  1550.         retCustomData.type = gNullCharPtr;

  1551.     }

  1552. 

  1553.     if (retCustomData.key != gNullCharPtr)

  1554.     {

  1555.         delete[] retCustomData.key;

  1556.         retCustomData.key = gNullCharPtr;

  1557.     }

  1558. 

  1559.     if (retCustomData.value != gNullCharPtr)

  1560.     {

  1561.         delete[] retCustomData.value;

  1562.         retCustomData.value = gNullCharPtr;

  1563.     }

  1564. 

  1565.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retCustomData);

  1566. 

  1567.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1568.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retCustomData);

  1569. 

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

  1571.     CARLA_SAFE_ASSERT_RETURN(customDataId < plugin->getCustomDataCount(), &retCustomData)

  1572. 

  1573.     const CustomData& pluginCustomData(plugin->getCustomData(customDataId));

  1574.     retCustomData.type  = carla_strdup_safe(pluginCustomData.type);

  1575.     retCustomData.key   = carla_strdup_safe(pluginCustomData.key);

  1576.     retCustomData.value = carla_strdup_safe(pluginCustomData.value);

  1577.     checkStringPtr(retCustomData.type);

  1578.     checkStringPtr(retCustomData.key);

  1579.     checkStringPtr(retCustomData.value);

  1580.     return &retCustomData;

  1581. }

  1582. 

  1583. const char* carla_get_custom_data_value(uint pluginId, const char* type, const char* key)

  1584. {

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

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

  1587.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1588. 

  1589.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1590.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1591. 

  1592.     carla_debug("carla_get_custom_data_value(%i, %s, %s)", pluginId, type, key);

  1593. 

  1594.     const uint32_t count = plugin->getCustomDataCount();

  1595. 

  1596.     if (count == 0)

  1597.         return gNullCharPtr;

  1598. 

  1599.     static CarlaString customDataValue;

  1600. 

  1601.     for (uint32_t i=0; i<count; ++i)

  1602.     {

  1603.         const CustomData& pluginCustomData(plugin->getCustomData(i));

  1604. 

  1605.         if (std::strcmp(pluginCustomData.type, type) != 0)

  1606.             continue;

  1607.         if (std::strcmp(pluginCustomData.key, key) != 0)

  1608.             continue;

  1609. 

  1610.         customDataValue = pluginCustomData.value;

  1611.         return customDataValue.buffer();

  1612.     }

  1613. 

  1614.     return gNullCharPtr;

  1615. }

  1616. 

  1617. const char* carla_get_chunk_data(uint pluginId)

  1618. {

  1619.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1620. 

  1621.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1622.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1623. 

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

  1625.     CARLA_SAFE_ASSERT_RETURN(plugin->getOptionsEnabled() & CB::PLUGIN_OPTION_USE_CHUNKS, gNullCharPtr);

  1626. 

  1627.     void* data = nullptr;

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

  1629.     CARLA_SAFE_ASSERT_RETURN(data != nullptr && dataSize > 0, gNullCharPtr);

  1630. 

  1631.     static CarlaString chunkData;

  1632. 

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

  1634.     return chunkData.buffer();

  1635. }

  1636. 

  1637. // --------------------------------------------------------------------------------------------------------------------

  1638. 

  1639. uint32_t carla_get_parameter_count(uint pluginId)

  1640. {

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

  1642. 

  1643.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1644.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0);

  1645. 

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

  1647.     return plugin->getParameterCount();

  1648. }

  1649. 

  1650. uint32_t carla_get_program_count(uint pluginId)

  1651. {

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

  1653. 

  1654.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1655.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0);

  1656. 

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

  1658.     return plugin->getProgramCount();

  1659. }

  1660. 

  1661. uint32_t carla_get_midi_program_count(uint pluginId)

  1662. {

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

  1664. 

  1665.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1666.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0);

  1667. 

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

  1669.     return plugin->getMidiProgramCount();

  1670. }

  1671. 

  1672. uint32_t carla_get_custom_data_count(uint pluginId)

  1673. {

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

  1675. 

  1676.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1677.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0);

  1678. 

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

  1680.     return plugin->getCustomDataCount();

  1681. }

  1682. 

  1683. // --------------------------------------------------------------------------------------------------------------------

  1684. 

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

  1686. {

  1687.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1688. 

  1689.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1690.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1691. 

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

  1693.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), gNullCharPtr);

  1694. 

  1695.     static char textBuf[STR_MAX+1];

  1696.     carla_zeroChars(textBuf, STR_MAX+1);

  1697. 

  1698.     if (! plugin->getParameterText(parameterId, textBuf))

  1699.         textBuf[0] = '\0';

  1700. 

  1701.     return textBuf;

  1702. }

  1703. 

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

  1705. {

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

  1707. 

  1708.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1709.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1710. 

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

  1712.     CARLA_SAFE_ASSERT_RETURN(programId < plugin->getProgramCount(), gNullCharPtr);

  1713. 

  1714.     static char programName[STR_MAX+1];

  1715.     carla_zeroChars(programName, STR_MAX+1);

  1716. 

  1717.     if (! plugin->getProgramName(programId, programName))

  1718.         programName[0] = '\0';

  1719. 

  1720.     return programName;

  1721. }

  1722. 

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

  1724. {

  1725.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1726. 

  1727.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1728.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1729. 

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

  1731.     CARLA_SAFE_ASSERT_RETURN(midiProgramId < plugin->getMidiProgramCount(), gNullCharPtr);

  1732. 

  1733.     static char midiProgramName[STR_MAX+1];

  1734.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1735. 

  1736.     if (! plugin->getMidiProgramName(midiProgramId, midiProgramName))

  1737.         midiProgramName[0] = '\0';

  1738. 

  1739.     return midiProgramName;

  1740. }

  1741. 

  1742. const char* carla_get_real_plugin_name(uint pluginId)

  1743. {

  1744.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1745. 

  1746.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1747.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1748. 

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

  1750.     static char realPluginName[STR_MAX+1];

  1751.     carla_zeroChars(realPluginName, STR_MAX+1);

  1752. 

  1753.     if (! plugin->getRealName(realPluginName))

  1754.         realPluginName[0] = '\0';

  1755. 

  1756.     return realPluginName;

  1757. }

  1758. 

  1759. // --------------------------------------------------------------------------------------------------------------------

  1760. 

  1761. int32_t carla_get_current_program_index(uint pluginId)

  1762. {

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

  1764. 

  1765.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1766.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, -1);

  1767. 

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

  1769.     return plugin->getCurrentProgram();

  1770. }

  1771. 

  1772. int32_t carla_get_current_midi_program_index(uint pluginId)

  1773. {

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

  1775. 

  1776.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1777.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, -1);

  1778. 

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

  1780.     return plugin->getCurrentMidiProgram();

  1781. }

  1782. 

  1783. // --------------------------------------------------------------------------------------------------------------------

  1784. 

  1785. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1786. {

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

  1788. 

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

  1790.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0.0f);

  1791. 

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

  1793.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), 0.0f);

  1794. 

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

  1796. }

  1797. 

  1798. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1799. {

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

  1801. 

  1802.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1803.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0.0f);

  1804.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), 0.0f);

  1805. 

  1806.     return plugin->getParameterValue(parameterId);

  1807. }

  1808. 

  1809. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1810. {

  1811. #ifdef BUILD_BRIDGE

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

  1813. #else

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

  1815. #endif

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

  1817. 

  1818.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1819.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0.0f);

  1820. 

  1821.     carla_debug("carla_get_internal_parameter_value(%i, %i)", pluginId, parameterId);

  1822.     return plugin->getInternalParameterValue(parameterId);

  1823. }

  1824. 

  1825. // --------------------------------------------------------------------------------------------------------------------

  1826. 

  1827. const float* carla_get_peak_values(uint pluginId)

  1828. {

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

  1830. 

  1831.     return gStandalone.engine->getPeaks(pluginId);

  1832. }

  1833. 

  1834. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1835. {

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

  1837. 

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

  1839. }

  1840. 

  1841. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1842. {

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

  1844. 

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

  1846. }

  1847. 

  1848. // --------------------------------------------------------------------------------------------------------------------

  1849. 

  1850. CARLA_BACKEND_START_NAMESPACE

  1851. 

  1852. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1853. // defined in CarlaPluginInternal.cpp

  1854. const void* carla_render_inline_display_internal(CarlaPlugin* plugin, uint32_t  width, uint32_t height);

  1855. #endif

  1856. 

  1857. // defined in CarlaPluginLV2.cpp

  1858. const void* carla_render_inline_display_lv2(CarlaPlugin* plugin, uint32_t width, uint32_t height);

  1859. 

  1860. CARLA_BACKEND_END_NAMESPACE

  1861. 

  1862. const CarlaInlineDisplayImageSurface* carla_render_inline_display(uint pluginId, uint32_t width, uint32_t height)

  1863. {

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

  1865. 

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

  1867.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, nullptr);

  1868. 

  1869.     carla_debug("carla_render_inline_display(%i, %i, %i)", pluginId, width, height);

  1870. 

  1871.     switch (plugin->getType())

  1872.     {

  1873. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1874.     case CB::PLUGIN_INTERNAL:

  1875.         return (const CarlaInlineDisplayImageSurface*)CB::carla_render_inline_display_internal(plugin, width, height);

  1876. #endif

  1877.     case CB::PLUGIN_LV2:

  1878.         return (const CarlaInlineDisplayImageSurface*)CB::carla_render_inline_display_lv2(plugin, width, height);

  1879.     default:

  1880.         return nullptr;

  1881.     }

  1882. }

  1883. 

  1884. // --------------------------------------------------------------------------------------------------------------------

  1885. 

  1886. void carla_set_active(uint pluginId, bool onOff)

  1887. {

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

  1889. 

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

  1891.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1892. 

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

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

  1895. }

  1896. 

  1897. #ifndef BUILD_BRIDGE

  1898. void carla_set_drywet(uint pluginId, float value)

  1899. {

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

  1901. 

  1902.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1903.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1904. 

  1905.     carla_debug("carla_set_drywet(%i, %f)", pluginId, static_cast<double>(value));

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

  1907. }

  1908. 

  1909. void carla_set_volume(uint pluginId, float value)

  1910. {

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

  1912. 

  1913.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1914.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1915. 

  1916.     carla_debug("carla_set_volume(%i, %f)", pluginId, static_cast<double>(value));

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

  1918. }

  1919. 

  1920. void carla_set_balance_left(uint pluginId, float value)

  1921. {

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

  1923. 

  1924.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1925.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1926. 

  1927.     carla_debug("carla_set_balance_left(%i, %f)", pluginId, static_cast<double>(value));

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

  1929. }

  1930. 

  1931. void carla_set_balance_right(uint pluginId, float value)

  1932. {

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

  1934. 

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

  1936.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1937. 

  1938.     carla_debug("carla_set_balance_right(%i, %f)", pluginId, static_cast<double>(value));

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

  1940. }

  1941. 

  1942. void carla_set_panning(uint pluginId, float value)

  1943. {

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

  1945. 

  1946.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1947.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1948. 

  1949.     carla_debug("carla_set_panning(%i, %f)", pluginId, static_cast<double>(value));

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

  1951. }

  1952. 

  1953. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1954. {

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

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

  1957. 

  1958.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1959.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1960. 

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

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

  1963. }

  1964. #endif

  1965. 

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

  1967. {

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

  1969. 

  1970.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1971.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1972. 

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

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

  1975. }

  1976. 

  1977. // --------------------------------------------------------------------------------------------------------------------

  1978. 

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

  1980. {

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

  1982. 

  1983.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1984.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1985. 

  1986.     carla_debug("carla_set_parameter_value(%i, %i, %f)", pluginId, parameterId, static_cast<double>(value));

  1987.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(),);

  1988. 

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

  1990. }

  1991. 

  1992. #ifndef BUILD_BRIDGE

  1993. 

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

  1995. {

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

  1997.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1998. 

  1999.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2000.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2001. 

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

  2003.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(),);

  2004. 

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

  2006. }

  2007. 

  2008. void carla_set_parameter_mapped_control_index(uint pluginId, uint32_t parameterId, int16_t index)

  2009. {

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

  2011.     CARLA_SAFE_ASSERT_RETURN(index >= CB::CONTROL_INDEX_NONE && index <= CB::CONTROL_INDEX_MAX_ALLOWED,);

  2012. 

  2013.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2014.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2015. 

  2016.     carla_debug("carla_set_parameter_mapped_control_index(%i, %i, %i)", pluginId, parameterId, index);

  2017.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(),);

  2018. 

  2019.     return plugin->setParameterMappedControlIndex(parameterId, index, true, false);

  2020. }

  2021. 

  2022. void carla_set_parameter_mapped_range(uint pluginId, uint32_t parameterId, float minimum, float maximum)

  2023. {

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

  2025. 

  2026.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2027.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2028. 

  2029.     carla_debug("carla_set_parameter_mapped_range(%i, %i, %f, %f)", pluginId, parameterId, static_cast<double>(minimum), static_cast<double>(maximum));

  2030.     CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(),);

  2031. 

  2032.     return plugin->setParameterMappedRange(parameterId, minimum, maximum, true, false);

  2033. }

  2034. 

  2035. void carla_set_parameter_touch(uint pluginId, uint32_t parameterId, bool touch)

  2036. {

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

  2038. 

  2039.     carla_debug("carla_set_parameter_touch(%i, %i, %s)", pluginId, parameterId, bool2str(touch));

  2040.     return gStandalone.engine->touchPluginParameter(pluginId, parameterId, touch);

  2041. }

  2042. #endif

  2043. 

  2044. // --------------------------------------------------------------------------------------------------------------------

  2045. 

  2046. void carla_set_program(uint pluginId, uint32_t programId)

  2047. {

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

  2049. 

  2050.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2051.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2052. 

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

  2054.     CARLA_SAFE_ASSERT_RETURN(programId < plugin->getProgramCount(),);

  2055. 

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

  2057. }

  2058. 

  2059. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2060. {

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

  2062. 

  2063.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2064.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2065. 

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

  2067.     CARLA_SAFE_ASSERT_RETURN(midiProgramId < plugin->getMidiProgramCount(),);

  2068. 

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

  2070. }

  2071. 

  2072. // --------------------------------------------------------------------------------------------------------------------

  2073. 

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

  2075. {

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

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

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

  2079.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2080. 

  2081.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2082.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2083. 

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

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

  2086. }

  2087. 

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

  2089. {

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

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

  2092. 

  2093.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2094.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2095. 

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

  2097.     CARLA_SAFE_ASSERT_RETURN(plugin->getOptionsEnabled() & CB::PLUGIN_OPTION_USE_CHUNKS,);

  2098. 

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

  2100. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2102. #else

  2103.     return plugin->setChunkData(&chunk.front(), chunk.size());

  2104. #endif

  2105. }

  2106. 

  2107. // --------------------------------------------------------------------------------------------------------------------

  2108. 

  2109. void carla_prepare_for_save(uint pluginId)

  2110. {

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

  2112. 

  2113.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2114.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2115. 

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

  2117.     return plugin->prepareForSave();

  2118. }

  2119. 

  2120. void carla_reset_parameters(uint pluginId)

  2121. {

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

  2123. 

  2124.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2125.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2126. 

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

  2128.     return plugin->resetParameters();

  2129. }

  2130. 

  2131. void carla_randomize_parameters(uint pluginId)

  2132. {

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

  2134. 

  2135.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2136.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2137. 

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

  2139.     return plugin->randomizeParameters();

  2140. }

  2141. 

  2142. #ifndef BUILD_BRIDGE

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

  2144. {

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

  2146. 

  2147.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2148.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2149. 

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

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

  2152. }

  2153. #endif

  2154. 

  2155. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2156. {

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

  2158. 

  2159.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2160.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2161. 

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

  2163.     return plugin->showCustomUI(yesNo);

  2164. }

  2165. 

  2166. // --------------------------------------------------------------------------------------------------------------------

  2167. 

  2168. uint32_t carla_get_buffer_size()

  2169. {

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

  2171. 

  2172.     carla_debug("carla_get_buffer_size()");

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

  2174. }

  2175. 

  2176. double carla_get_sample_rate()

  2177. {

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

  2179. 

  2180.     carla_debug("carla_get_sample_rate()");

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

  2182. }

  2183. 

  2184. // --------------------------------------------------------------------------------------------------------------------

  2185. 

  2186. const char* carla_get_last_error()

  2187. {

  2188.     carla_debug("carla_get_last_error()");

  2189. 

  2190.     if (gStandalone.engine != nullptr)

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

  2192. 

  2193.     return gStandalone.lastError;

  2194. }

  2195. 

  2196. const char* carla_get_host_osc_url_tcp()

  2197. {

  2198.     carla_debug("carla_get_host_osc_url_tcp()");

  2199. 

  2200. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2201.     if (gStandalone.engine == nullptr)

  2202.     {

  2203.         carla_stderr2("carla_get_host_osc_url_tcp() failed, engine is not running");

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

  2205.         return gNullCharPtr;

  2206.     }

  2207. 

  2208.     const char* const path = gStandalone.engine->getOscServerPathTCP();

  2209. 

  2210.     if (path != nullptr && path[0] != '\0')

  2211.         return path;

  2212. 

  2213.     static const char* const notAvailable = "(OSC TCP port not available)";

  2214.     return notAvailable;

  2215. #else

  2216.     return gNullCharPtr;

  2217. #endif

  2218. }

  2219. 

  2220. const char* carla_get_host_osc_url_udp()

  2221. {

  2222.     carla_debug("carla_get_host_osc_url_udp()");

  2223. 

  2224. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2225.     if (gStandalone.engine == nullptr)

  2226.     {

  2227.         carla_stderr2("carla_get_host_osc_url_udp() failed, engine is not running");

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

  2229.         return gNullCharPtr;

  2230.     }

  2231. 

  2232.     const char* const path = gStandalone.engine->getOscServerPathUDP();

  2233. 

  2234.     if (path != nullptr && path[0] != '\0')

  2235.         return path;

  2236. 

  2237.     static const char* const notAvailable = "(OSC UDP port not available)";

  2238.     return notAvailable;

  2239. #else

  2240.     return gNullCharPtr;

  2241. #endif

  2242. }

  2243. 

  2244. // --------------------------------------------------------------------------------------------------------------------

  2245. 

  2246. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2247. #include "CarlaPluginUI.cpp"

  2248. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2249. 

  2250. #include "CarlaDssiUtils.cpp"

  2251. #include "CarlaMacUtils.cpp"

  2252. #include "CarlaPatchbayUtils.cpp"

  2253. #include "CarlaPipeUtils.cpp"

  2254. #include "CarlaStateUtils.cpp"

  2255. 

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