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.
2201 Commits
16 Branches
275MB
Tree: 65fcdf868e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '65fcdf868e'
${ noResults }
Carla/source/backend/engine/CarlaEngine.cpp

1634 lines
52KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. /* TODO:

  19.  * - complete processRack(): carefully add to input, sorted events

  20.  * - implement processPatchbay()

  21.  * - implement oscSend_control_switch_plugins()

  22.  * - proper find&load plugins

  23.  * - something about the peaks?

  24.  */

  25. 

  26. #include "CarlaEngineInternal.hpp"

  27. #include "CarlaPlugin.hpp"

  28. 

  29. #include "CarlaBackendUtils.hpp"

  30. #include "CarlaBinaryUtils.hpp"

  31. #include "CarlaEngineUtils.hpp"

  32. #include "CarlaMathUtils.hpp"

  33. #include "CarlaStateUtils.hpp"

  34. #include "CarlaMIDI.h"

  35. 

  36. #include "jackbridge/JackBridge.hpp"

  37. #include "juce_core.h"

  38. 

  39. using juce::File;

  40. using juce::MemoryOutputStream;

  41. using juce::ScopedPointer;

  42. using juce::String;

  43. using juce::XmlDocument;

  44. using juce::XmlElement;

  45. 

  46. CARLA_BACKEND_START_NAMESPACE

  47. 

  48. // -----------------------------------------------------------------------

  49. // Carla Engine

  50. 

  51. CarlaEngine::CarlaEngine()

  52.     : pData(new ProtectedData(this))

  53. {

  54.     carla_debug("CarlaEngine::CarlaEngine()");

  55. }

  56. 

  57. CarlaEngine::~CarlaEngine()

  58. {

  59.     carla_debug("CarlaEngine::~CarlaEngine()");

  60. 

  61.     delete pData;

  62. }

  63. 

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

  65. // Static calls

  66. 

  67. uint CarlaEngine::getDriverCount()

  68. {

  69.     carla_debug("CarlaEngine::getDriverCount()");

  70. 

  71.     uint count = 0;

  72. 

  73.     if (jackbridge_is_ok())

  74.         count += 1;

  75. 

  76. #ifndef BUILD_BRIDGE

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

  78.     count += getJuceApiCount();

  79. # else

  80.     count += getRtAudioApiCount();

  81. # endif

  82. #endif

  83. 

  84.     return count;

  85. }

  86. 

  87. const char* CarlaEngine::getDriverName(const uint index2)

  88. {

  89.     carla_debug("CarlaEngine::getDriverName(%i)", index2);

  90. 

  91.     uint index(index2);

  92. 

  93.     if (jackbridge_is_ok() && index-- == 0)

  94.         return "JACK";

  95. 

  96. #ifndef BUILD_BRIDGE

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

  98.     if (const uint count = getJuceApiCount())

  99.     {

  100.         if (index < count)

  101.             return getJuceApiName(index);

  102.         index -= count;

  103.     }

  104. # else

  105.     if (const uint count = getRtAudioApiCount())

  106.     {

  107.         if (index < count)

  108.             return getRtAudioApiName(index);

  109.         index -= count;

  110.     }

  111. # endif

  112. #endif

  113. 

  114.     carla_stderr("CarlaEngine::getDriverName(%i) - invalid index", index2);

  115.     return nullptr;

  116. }

  117. 

  118. const char* const* CarlaEngine::getDriverDeviceNames(const uint index2)

  119. {

  120.     carla_debug("CarlaEngine::getDriverDeviceNames(%i)", index2);

  121. 

  122.     uint index(index2);

  123. 

  124.     if (jackbridge_is_ok() && index-- == 0)

  125.     {

  126.         static const char* ret[3] = { "Auto-Connect OFF", "Auto-Connect ON", nullptr };

  127.         return ret;

  128.     }

  129. 

  130. #ifndef BUILD_BRIDGE

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

  132.     if (const uint count = getJuceApiCount())

  133.     {

  134.         if (index < count)

  135.             return getJuceApiDeviceNames(index);

  136.         index -= count;

  137.     }

  138. # else

  139.     if (const uint count = getRtAudioApiCount())

  140.     {

  141.         if (index < count)

  142.             return getRtAudioApiDeviceNames(index);

  143.         index -= count;

  144.     }

  145. # endif

  146. #endif

  147. 

  148.     carla_stderr("CarlaEngine::getDriverDeviceNames(%i) - invalid index", index2);

  149.     return nullptr;

  150. }

  151. 

  152. const EngineDriverDeviceInfo* CarlaEngine::getDriverDeviceInfo(const uint index2, const char* const deviceName)

  153. {

  154.     carla_debug("CarlaEngine::getDriverDeviceInfo(%i, \"%s\")", index2, deviceName);

  155. 

  156.     uint index(index2);

  157. 

  158.     if (jackbridge_is_ok() && index-- == 0)

  159.     {

  160.         static uint32_t bufSizes[11] = { 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 0 };

  161.         static EngineDriverDeviceInfo devInfo;

  162.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  163.         devInfo.bufferSizes = bufSizes;

  164.         devInfo.sampleRates = nullptr;

  165.         return &devInfo;

  166.     }

  167. 

  168. #ifndef BUILD_BRIDGE

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

  170.     if (const uint count = getJuceApiCount())

  171.     {

  172.         if (index < count)

  173.             return getJuceDeviceInfo(index, deviceName);

  174.         index -= count;

  175.     }

  176. # else

  177.     if (const uint count = getRtAudioApiCount())

  178.     {

  179.         if (index < count)

  180.             return getRtAudioDeviceInfo(index, deviceName);

  181.         index -= count;

  182.     }

  183. # endif

  184. #endif

  185. 

  186.     carla_stderr("CarlaEngine::getDriverDeviceNames(%i, \"%s\") - invalid index", index2, deviceName);

  187.     return nullptr;

  188. }

  189. 

  190. CarlaEngine* CarlaEngine::newDriverByName(const char* const driverName)

  191. {

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

  193.     carla_debug("CarlaEngine::newDriverByName(\"%s\")", driverName);

  194. 

  195.     if (std::strcmp(driverName, "JACK") == 0)

  196.         return newJack();

  197. 

  198. #ifndef BUILD_BRIDGE

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

  200.     // -------------------------------------------------------------------

  201.     // macos

  202. 

  203.     if (std::strcmp(driverName, "CoreAudio") == 0)

  204.         return newJuce(AUDIO_API_CORE);

  205. 

  206.     // -------------------------------------------------------------------

  207.     // windows

  208. 

  209.     if (std::strcmp(driverName, "ASIO") == 0)

  210.         return newJuce(AUDIO_API_ASIO);

  211.     if (std::strcmp(driverName, "DirectSound") == 0)

  212.         return newJuce(AUDIO_API_DS);

  213. #else

  214.     // -------------------------------------------------------------------

  215.     // common

  216. 

  217.     if (std::strncmp(driverName, "JACK ", 5) == 0)

  218.         return newRtAudio(AUDIO_API_JACK);

  219. 

  220.     // -------------------------------------------------------------------

  221.     // linux

  222. 

  223.     if (std::strcmp(driverName, "ALSA") == 0)

  224.         return newRtAudio(AUDIO_API_ALSA);

  225.     if (std::strcmp(driverName, "OSS") == 0)

  226.         return newRtAudio(AUDIO_API_OSS);

  227.     if (std::strcmp(driverName, "PulseAudio") == 0)

  228.         return newRtAudio(AUDIO_API_PULSE);

  229. # endif

  230. #endif

  231. 

  232.     carla_stderr("CarlaEngine::newDriverByName(\"%s\") - invalid driver name", driverName);

  233.     return nullptr;

  234. }

  235. 

  236. // -----------------------------------------------------------------------

  237. // Constant values

  238. 

  239. uint CarlaEngine::getMaxClientNameSize() const noexcept

  240. {

  241.     return STR_MAX/2;

  242. }

  243. 

  244. uint CarlaEngine::getMaxPortNameSize() const noexcept

  245. {

  246.     return STR_MAX;

  247. }

  248. 

  249. uint CarlaEngine::getCurrentPluginCount() const noexcept

  250. {

  251.     return pData->curPluginCount;

  252. }

  253. 

  254. uint CarlaEngine::getMaxPluginNumber() const noexcept

  255. {

  256.     return pData->maxPluginNumber;

  257. }

  258. 

  259. // -----------------------------------------------------------------------

  260. // Virtual, per-engine type calls

  261. 

  262. bool CarlaEngine::init(const char* const clientName)

  263. {

  264.     carla_debug("CarlaEngine::init(\"%s\")", clientName);

  265. 

  266.     if (! pData->init(clientName))

  267.         return false;

  268. 

  269.     callback(ENGINE_CALLBACK_ENGINE_STARTED, 0, pData->options.processMode, pData->options.transportMode, 0.0f, getCurrentDriverName());

  270.     return true;

  271. }

  272. 

  273. bool CarlaEngine::close()

  274. {

  275.     carla_debug("CarlaEngine::close()");

  276. 

  277.     if (pData->curPluginCount != 0)

  278.     {

  279.         pData->aboutToClose = true;

  280.         removeAllPlugins();

  281.     }

  282. 

  283. #ifndef BUILD_BRIDGE

  284.     if (pData->osc.isControlRegistered())

  285.         oscSend_control_exit();

  286. #endif

  287. 

  288.     pData->close();

  289. 

  290.     callback(ENGINE_CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0.0f, nullptr);

  291.     return true;

  292. }

  293. 

  294. void CarlaEngine::idle() noexcept

  295. {

  296.     CARLA_SAFE_ASSERT_RETURN(pData->nextAction.opcode == kEnginePostActionNull,); // FIXME REMOVE

  297.     CARLA_SAFE_ASSERT_RETURN(pData->nextPluginId == pData->maxPluginNumber,);

  298. 

  299.     for (uint i=0; i < pData->curPluginCount; ++i)

  300.     {

  301.         CarlaPlugin* const plugin(pData->plugins[i].plugin);

  302. 

  303.         if (plugin != nullptr && plugin->isEnabled())

  304.         {

  305.             try {

  306.                 plugin->idle();

  307.             } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin idle");

  308.         }

  309.     }

  310. 

  311.     pData->osc.idle();

  312. }

  313. 

  314. CarlaEngineClient* CarlaEngine::addClient(CarlaPlugin* const)

  315. {

  316.     return new CarlaEngineClient(*this);

  317. }

  318. 

  319. // -----------------------------------------------------------------------

  320. // Plugin management

  321. 

  322. bool CarlaEngine::addPlugin(const BinaryType btype, const PluginType ptype, const char* const filename, const char* const name, const char* const label, const int64_t uniqueId, const void* const extra)

  323. {

  324.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  325.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  326.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId <= pData->maxPluginNumber, "Invalid engine internal data");

  327.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  328.     CARLA_SAFE_ASSERT_RETURN_ERR(btype != BINARY_NONE, "Invalid plugin binary mode");

  329.     CARLA_SAFE_ASSERT_RETURN_ERR(ptype != PLUGIN_NONE, "Invalid plugin type");

  330.     CARLA_SAFE_ASSERT_RETURN_ERR((filename != nullptr && filename[0] != '\0') || (label != nullptr && label[0] != '\0'), "Invalid plugin filename and label");

  331.     carla_debug("CarlaEngine::addPlugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p)", btype, BinaryType2Str(btype), ptype, PluginType2Str(ptype), filename, name, label, uniqueId, extra);

  332. 

  333.     uint id;

  334. 

  335. #ifndef BUILD_BRIDGE

  336.     CarlaPlugin* oldPlugin = nullptr;

  337. 

  338.     if (pData->nextPluginId < pData->curPluginCount)

  339.     {

  340.         id = pData->nextPluginId;

  341.         pData->nextPluginId = pData->maxPluginNumber;

  342. 

  343.         oldPlugin = pData->plugins[id].plugin;

  344. 

  345.         CARLA_SAFE_ASSERT_RETURN_ERR(oldPlugin != nullptr, "Invalid replace plugin Id");

  346.     }

  347.     else

  348. #endif

  349.     {

  350.         id = pData->curPluginCount;

  351. 

  352.         if (id == pData->maxPluginNumber)

  353.         {

  354.             setLastError("Maximum number of plugins reached");

  355.             return false;

  356.         }

  357. 

  358.         CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins[id].plugin == nullptr, "Invalid engine internal data");

  359.     }

  360. 

  361.     CarlaPlugin::Initializer initializer = {

  362.         this,

  363.         id,

  364.         filename,

  365.         name,

  366.         label,

  367.         uniqueId

  368.     };

  369. 

  370.     CarlaPlugin* plugin = nullptr;

  371. 

  372. #ifndef BUILD_BRIDGE

  373.     CarlaString bridgeBinary(pData->options.binaryDir);

  374. 

  375.     if (bridgeBinary.isNotEmpty())

  376.     {

  377. # ifndef CARLA_OS_WIN

  378.         if (btype == BINARY_NATIVE)

  379.         {

  380.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-native";

  381.         }

  382.         else

  383. # endif

  384.         {

  385.             switch (btype)

  386.             {

  387.             case BINARY_POSIX32:

  388.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-posix32";

  389.                 break;

  390.             case BINARY_POSIX64:

  391.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-posix64";

  392.                 break;

  393.             case BINARY_WIN32:

  394.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-win32.exe";

  395.                 break;

  396.             case BINARY_WIN64:

  397.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-win64.exe";

  398.                 break;

  399.             default:

  400.                 bridgeBinary.clear();

  401.                 break;

  402.             }

  403.         }

  404. 

  405.         if (! File(bridgeBinary.buffer()).existsAsFile())

  406.             bridgeBinary.clear();

  407.     }

  408. 

  409.     if (ptype != PLUGIN_INTERNAL && (btype != BINARY_NATIVE || (pData->options.preferPluginBridges && bridgeBinary.isNotEmpty())))

  410.     {

  411.         if (bridgeBinary.isNotEmpty())

  412.         {

  413.             plugin = CarlaPlugin::newBridge(initializer, btype, ptype, bridgeBinary);

  414.         }

  415. # ifdef CARLA_OS_LINUX

  416.         // fallback to dssi-vst if possible

  417.         else if (btype == BINARY_WIN32 && File("/usr/lib/dssi/dssi-vst.so").existsAsFile())

  418.         {

  419.             File file(filename);

  420. 

  421.             CarlaString label2(file.getFileName().toRawUTF8());

  422.             label2.replace(' ', '*');

  423. 

  424.             CarlaPlugin::Initializer init2 = {

  425.                 this,

  426.                 id,

  427.                 "/usr/lib/dssi/dssi-vst.so",

  428.                 name,

  429.                 label2,

  430.                 uniqueId

  431.             };

  432. 

  433.             char* const oldVstPath(getenv("VST_PATH"));

  434.             carla_setenv("VST_PATH", file.getParentDirectory().getFullPathName().toRawUTF8());

  435. 

  436.             plugin = CarlaPlugin::newDSSI(init2);

  437. 

  438.             if (oldVstPath != nullptr)

  439.                 carla_setenv("VST_PATH", oldVstPath);

  440.         }

  441. # endif

  442.         else

  443.         {

  444.             setLastError("This Carla build cannot handle this binary");

  445.             return false;

  446.         }

  447.     }

  448.     else

  449. #endif // ! BUILD_BRIDGE

  450.     {

  451.         bool use16Outs;

  452.         setLastError("Invalid or unsupported plugin type");

  453. 

  454.         switch (ptype)

  455.         {

  456.         case PLUGIN_NONE:

  457.             break;

  458. 

  459.         case PLUGIN_INTERNAL:

  460.             /*if (std::strcmp(label, "FluidSynth") == 0)

  461.             {

  462.                 use16Outs = (extra != nullptr && std::strcmp((const char*)extra, "true") == 0);

  463.                 plugin = CarlaPlugin::newFluidSynth(initializer, use16Outs);

  464.             }

  465.             else if (std::strcmp(label, "LinuxSampler (GIG)") == 0)

  466.             {

  467.                 use16Outs = (extra != nullptr && std::strcmp((const char*)extra, "true") == 0);

  468.                 plugin = CarlaPlugin::newLinuxSampler(initializer, "GIG", use16Outs);

  469.             }

  470.             else if (std::strcmp(label, "LinuxSampler (SF2)") == 0)

  471.             {

  472.                 use16Outs = (extra != nullptr && std::strcmp((const char*)extra, "true") == 0);

  473.                 plugin = CarlaPlugin::newLinuxSampler(initializer, "SF2", use16Outs);

  474.             }

  475.             else if (std::strcmp(label, "LinuxSampler (SFZ)") == 0)

  476.             {

  477.                 use16Outs = (extra != nullptr && std::strcmp((const char*)extra, "true") == 0);

  478.                 plugin = CarlaPlugin::newLinuxSampler(initializer, "SFZ", use16Outs);

  479.             }*/

  480.             plugin = CarlaPlugin::newNative(initializer);

  481.             break;

  482. 

  483.         case PLUGIN_LADSPA:

  484.             plugin = CarlaPlugin::newLADSPA(initializer, (const LADSPA_RDF_Descriptor*)extra);

  485.             break;

  486. 

  487.         case PLUGIN_DSSI:

  488.             plugin = CarlaPlugin::newDSSI(initializer);

  489.             break;

  490. 

  491.         case PLUGIN_LV2:

  492.             plugin = CarlaPlugin::newLV2(initializer);

  493.             break;

  494. 

  495.         case PLUGIN_VST:

  496.             plugin = CarlaPlugin::newVST(initializer);

  497.             break;

  498. 

  499.         case PLUGIN_VST3:

  500.             plugin = CarlaPlugin::newVST3(initializer);

  501.             break;

  502. 

  503.         case PLUGIN_AU:

  504.             plugin = CarlaPlugin::newAU(initializer);

  505.             break;

  506. 

  507.         case PLUGIN_GIG:

  508.             use16Outs = (extra != nullptr && std::strcmp((const char*)extra, "true") == 0);

  509.             plugin = CarlaPlugin::newFileGIG(initializer, use16Outs);

  510.             break;

  511. 

  512.         case PLUGIN_SF2:

  513.             use16Outs = (extra != nullptr && std::strcmp((const char*)extra, "true") == 0);

  514.             plugin = CarlaPlugin::newFileSF2(initializer, use16Outs);

  515.             break;

  516. 

  517.         case PLUGIN_SFZ:

  518.             plugin = CarlaPlugin::newFileSFZ(initializer);

  519.             break;

  520.         }

  521.     }

  522. 

  523.     if (plugin == nullptr)

  524.         return false;

  525. 

  526.     plugin->registerToOscClient();

  527. 

  528.     EnginePluginData& pluginData(pData->plugins[id]);

  529.     pluginData.plugin      = plugin;

  530.     pluginData.insPeak[0]  = 0.0f;

  531.     pluginData.insPeak[1]  = 0.0f;

  532.     pluginData.outsPeak[0] = 0.0f;

  533.     pluginData.outsPeak[1] = 0.0f;

  534. 

  535. #ifndef BUILD_BRIDGE

  536.     if (oldPlugin != nullptr)

  537.     {

  538.         // the engine thread might be reading from the old plugin

  539.         pData->thread.stopThread(500);

  540.         pData->thread.startThread();

  541. 

  542.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  543.             pData->graph.replacePlugin(oldPlugin, plugin);

  544. 

  545.         const bool  wasActive = oldPlugin->getInternalParameterValue(PARAMETER_ACTIVE) >= 0.5f;

  546.         const float oldDryWet = oldPlugin->getInternalParameterValue(PARAMETER_DRYWET);

  547.         const float oldVolume = oldPlugin->getInternalParameterValue(PARAMETER_VOLUME);

  548. 

  549.         delete oldPlugin;

  550. 

  551.         if (plugin->getHints() & PLUGIN_CAN_DRYWET)

  552.             plugin->setDryWet(oldDryWet, true, true);

  553. 

  554.         if (plugin->getHints() & PLUGIN_CAN_VOLUME)

  555.             plugin->setVolume(oldVolume, true, true);

  556. 

  557.         if (wasActive)

  558.             plugin->setActive(true, true, true);

  559. 

  560.         callback(ENGINE_CALLBACK_RELOAD_ALL, id, 0, 0, 0.0f, nullptr);

  561.     }

  562.     else

  563. #endif

  564.     {

  565.         ++pData->curPluginCount;

  566.         callback(ENGINE_CALLBACK_PLUGIN_ADDED, id, 0, 0, 0.0f, plugin->getName());

  567. 

  568. #ifndef BUILD_BRIDGE

  569.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  570.             pData->graph.addPlugin(plugin);

  571. #endif

  572.     }

  573. 

  574.     return true;

  575. }

  576. 

  577. bool CarlaEngine::addPlugin(const PluginType ptype, const char* const filename, const char* const name, const char* const label, const int64_t uniqueId, const void* const extra)

  578. {

  579.     return addPlugin(BINARY_NATIVE, ptype, filename, name, label, uniqueId, extra);

  580. }

  581. 

  582. bool CarlaEngine::removePlugin(const uint id)

  583. {

  584.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  585.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  586.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data");

  587.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  588.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id");

  589.     carla_debug("CarlaEngine::removePlugin(%i)", id);

  590. 

  591.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  592. 

  593.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin != nullptr, "Could not find plugin to remove");

  594.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data");

  595. 

  596.     pData->thread.stopThread(500);

  597. 

  598. #ifndef BUILD_BRIDGE

  599.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  600.         pData->graph.removePlugin(plugin);

  601. 

  602.     const bool lockWait(isRunning() /*&& pData->options.processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS*/);

  603.     const ScopedActionLock sal(pData, kEnginePostActionRemovePlugin, id, 0, lockWait);

  604. 

  605.     for (uint i=id; i < pData->curPluginCount; ++i)

  606.     {

  607.         CarlaPlugin* const plugin2(pData->plugins[i].plugin);

  608.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  609.         plugin2->updateOscURL();

  610.     }

  611. 

  612.     if (isOscControlRegistered())

  613.         oscSend_control_remove_plugin(id);

  614. #else

  615.     pData->curPluginCount = 0;

  616.     carla_zeroStruct(pData->plugins, 1);

  617. #endif

  618. 

  619.     delete plugin;

  620. 

  621.     if (isRunning() && ! pData->aboutToClose)

  622.         pData->thread.startThread();

  623. 

  624.     callback(ENGINE_CALLBACK_PLUGIN_REMOVED, id, 0, 0, 0.0f, nullptr);

  625.     return true;

  626. }

  627. 

  628. bool CarlaEngine::removeAllPlugins()

  629. {

  630.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  631.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  632.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId == pData->maxPluginNumber, "Invalid engine internal data");

  633.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  634.     carla_debug("CarlaEngine::removeAllPlugins()");

  635. 

  636.     if (pData->curPluginCount == 0)

  637.         return true;

  638. 

  639.     pData->thread.stopThread(500);

  640. 

  641. #ifndef BUILD_BRIDGE

  642.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  643.         pData->graph.removeAllPlugins(this);

  644. #endif

  645. 

  646.     const uint32_t curPluginCount(pData->curPluginCount);

  647. 

  648.     const bool lockWait(isRunning());

  649.     const ScopedActionLock sal(pData, kEnginePostActionZeroCount, 0, 0, lockWait);

  650. 

  651.     callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  652. 

  653.     for (uint i=0; i < curPluginCount; ++i)

  654.     {

  655.         EnginePluginData& pluginData(pData->plugins[i]);

  656. 

  657.         if (pluginData.plugin != nullptr)

  658.         {

  659.             delete pluginData.plugin;

  660.             pluginData.plugin = nullptr;

  661.         }

  662. 

  663.         pluginData.insPeak[0]  = 0.0f;

  664.         pluginData.insPeak[1]  = 0.0f;

  665.         pluginData.outsPeak[0] = 0.0f;

  666.         pluginData.outsPeak[1] = 0.0f;

  667. 

  668.         callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  669.     }

  670. 

  671.     if (isRunning() && ! pData->aboutToClose)

  672.         pData->thread.startThread();

  673. 

  674.     return true;

  675. }

  676. 

  677. #ifndef BUILD_BRIDGE

  678. const char* CarlaEngine::renamePlugin(const uint id, const char* const newName)

  679. {

  680.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  681.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->plugins != nullptr, "Invalid engine internal data");

  682.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->curPluginCount != 0, "Invalid engine internal data");

  683.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  684.     CARLA_SAFE_ASSERT_RETURN_ERRN(id < pData->curPluginCount, "Invalid plugin Id");

  685.     CARLA_SAFE_ASSERT_RETURN_ERRN(newName != nullptr && newName[0] != '\0', "Invalid plugin name");

  686.     carla_debug("CarlaEngine::renamePlugin(%i, \"%s\")", id, newName);

  687. 

  688.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  689. 

  690.     CARLA_SAFE_ASSERT_RETURN_ERRN(plugin != nullptr, "Could not find plugin to rename");

  691.     CARLA_SAFE_ASSERT_RETURN_ERRN(plugin->getId() == id, "Invalid engine internal data");

  692. 

  693.     if (const char* const name = getUniquePluginName(newName))

  694.     {

  695.         plugin->setName(name);

  696.         return name;

  697.     }

  698. 

  699.     setLastError("Unable to get new unique plugin name");

  700.     return nullptr;

  701. }

  702. 

  703. bool CarlaEngine::clonePlugin(const uint id)

  704. {

  705.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  706.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  707.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data");

  708.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  709.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id");

  710.     carla_debug("CarlaEngine::clonePlugin(%i)", id);

  711. 

  712.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  713. 

  714.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin != nullptr, "Could not find plugin to clone");

  715.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data");

  716. 

  717.     char label[STR_MAX+1];

  718.     carla_zeroChar(label, STR_MAX+1);

  719.     plugin->getLabel(label);

  720. 

  721.     const uint pluginCountBefore(pData->curPluginCount);

  722. 

  723.     if (! addPlugin(plugin->getBinaryType(), plugin->getType(), plugin->getFilename(), plugin->getName(), label, plugin->getUniqueId(), plugin->getExtraStuff()))

  724.         return false;

  725. 

  726.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginCountBefore+1 == pData->curPluginCount, "No new plugin found");

  727. 

  728.     if (CarlaPlugin* const newPlugin = pData->plugins[pluginCountBefore].plugin)

  729.         newPlugin->loadStateSave(plugin->getStateSave());

  730. 

  731.     return true;

  732. }

  733. 

  734. bool CarlaEngine::replacePlugin(const uint id) noexcept

  735. {

  736.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  737.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  738.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data");

  739.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  740.     carla_debug("CarlaEngine::replacePlugin(%i)", id);

  741. 

  742.     // might use this to reset

  743.     if (id == pData->curPluginCount || id == pData->maxPluginNumber)

  744.     {

  745.         pData->nextPluginId = pData->maxPluginNumber;

  746.         return true;

  747.     }

  748. 

  749.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id");

  750. 

  751.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  752. 

  753.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin != nullptr, "Could not find plugin to replace");

  754.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data");

  755. 

  756.     pData->nextPluginId = id;

  757. 

  758.     return true;

  759. }

  760. 

  761. bool CarlaEngine::switchPlugins(const uint idA, const uint idB) noexcept

  762. {

  763.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  764.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  765.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount >= 2, "Invalid engine internal data");

  766.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  767.     CARLA_SAFE_ASSERT_RETURN_ERR(idA != idB, "Invalid operation, cannot switch plugin with itself");

  768.     CARLA_SAFE_ASSERT_RETURN_ERR(idA < pData->curPluginCount, "Invalid plugin Id");

  769.     CARLA_SAFE_ASSERT_RETURN_ERR(idB < pData->curPluginCount, "Invalid plugin Id");

  770.     carla_debug("CarlaEngine::switchPlugins(%i)", idA, idB);

  771. 

  772.     {

  773.         CarlaPlugin* const pluginA(pData->plugins[idA].plugin);

  774.         CarlaPlugin* const pluginB(pData->plugins[idB].plugin);

  775. 

  776.         CARLA_SAFE_ASSERT_RETURN_ERR(pluginA != nullptr, "Could not find plugin to switch");

  777.         CARLA_SAFE_ASSERT_RETURN_ERR(pluginA != nullptr, "Could not find plugin to switch");

  778.         CARLA_SAFE_ASSERT_RETURN_ERR(pluginA->getId() == idA, "Invalid engine internal data");

  779.         CARLA_SAFE_ASSERT_RETURN_ERR(pluginB->getId() == idB, "Invalid engine internal data");

  780. 

  781.         pData->thread.stopThread(500);

  782. 

  783.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  784.             pData->graph.replacePlugin(pluginA, pluginB);

  785.     }

  786. 

  787.     const bool lockWait(isRunning() /*&& pData->options.processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS*/);

  788.     const ScopedActionLock sal(pData, kEnginePostActionSwitchPlugins, idA, idB, lockWait);

  789. 

  790.     CarlaPlugin* const pluginA(pData->plugins[idA].plugin);

  791.     CarlaPlugin* const pluginB(pData->plugins[idB].plugin);

  792. 

  793.     if (pluginA != nullptr && pluginB != nullptr)

  794.     {

  795.         pluginA->updateOscURL();

  796.         pluginB->updateOscURL();

  797.     }

  798. 

  799.     // TODO

  800.     //if (isOscControlRegistered())

  801.     //    oscSend_control_switch_plugins(idA, idB);

  802. 

  803.     if (isRunning() && ! pData->aboutToClose)

  804.         pData->thread.startThread();

  805. 

  806.     return true;

  807. }

  808. #endif

  809. 

  810. CarlaPlugin* CarlaEngine::getPlugin(const uint id) const noexcept

  811. {

  812.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->plugins != nullptr, "Invalid engine internal data");

  813.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->curPluginCount != 0, "Invalid engine internal data");

  814.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  815.     CARLA_SAFE_ASSERT_RETURN_ERRN(id < pData->curPluginCount, "Invalid plugin Id");

  816. 

  817.     return pData->plugins[id].plugin;

  818. }

  819. 

  820. CarlaPlugin* CarlaEngine::getPluginUnchecked(const uint id) const noexcept

  821. {

  822.     return pData->plugins[id].plugin;

  823. }

  824. 

  825. const char* CarlaEngine::getUniquePluginName(const char* const name) const

  826. {

  827.     CARLA_SAFE_ASSERT_RETURN(pData->nextAction.opcode == kEnginePostActionNull, nullptr);

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

  829.     carla_debug("CarlaEngine::getUniquePluginName(\"%s\")", name);

  830. 

  831.     CarlaString sname;

  832.     sname = name;

  833. 

  834.     if (sname.isEmpty())

  835.     {

  836.         sname = "(No name)";

  837.         return sname.dup();

  838.     }

  839. 

  840.     const size_t maxNameSize(carla_min<uint>(getMaxClientNameSize(), 0xff, 6) - 6); // 6 = strlen(" (10)") + 1

  841. 

  842.     if (maxNameSize == 0 || ! isRunning())

  843.         return sname.dup();

  844. 

  845.     sname.truncate(maxNameSize);

  846.     sname.replace(':', '.'); // ':' is used in JACK1 to split client/port names

  847. 

  848.     for (uint i=0; i < pData->curPluginCount; ++i)

  849.     {

  850.         CARLA_SAFE_ASSERT_BREAK(pData->plugins[i].plugin != nullptr);

  851. 

  852.         // Check if unique name doesn't exist

  853.         if (const char* const pluginName = pData->plugins[i].plugin->getName())

  854.         {

  855.             if (sname != pluginName)

  856.                 continue;

  857.         }

  858. 

  859.         // Check if string has already been modified

  860.         {

  861.             const size_t len(sname.length());

  862. 

  863.             // 1 digit, ex: " (2)"

  864.             if (sname[len-4] == ' ' && sname[len-3] == '(' && sname.isDigit(len-2) && sname[len-1] == ')')

  865.             {

  866.                 int number = sname[len-2] - '0';

  867. 

  868.                 if (number == 9)

  869.                 {

  870.                     // next number is 10, 2 digits

  871.                     sname.truncate(len-4);

  872.                     sname += " (10)";

  873.                     //sname.replace(" (9)", " (10)");

  874.                 }

  875.                 else

  876.                     sname[len-2] = char('0' + number + 1);

  877. 

  878.                 continue;

  879.             }

  880. 

  881.             // 2 digits, ex: " (11)"

  882.             if (sname[len-5] == ' ' && sname[len-4] == '(' && sname.isDigit(len-3) && sname.isDigit(len-2) && sname[len-1] == ')')

  883.             {

  884.                 char n2 = sname[len-2];

  885.                 char n3 = sname[len-3];

  886. 

  887.                 if (n2 == '9')

  888.                 {

  889.                     n2 = '0';

  890.                     n3 = static_cast<char>(n3 + 1);

  891.                 }

  892.                 else

  893.                     n2 = static_cast<char>(n2 + 1);

  894. 

  895.                 sname[len-2] = n2;

  896.                 sname[len-3] = n3;

  897. 

  898.                 continue;

  899.             }

  900.         }

  901. 

  902.         // Modify string if not

  903.         sname += " (2)";

  904.     }

  905. 

  906.     return sname.dup();

  907. }

  908. 

  909. // -----------------------------------------------------------------------

  910. // Project management

  911. 

  912. bool CarlaEngine::loadFile(const char* const filename)

  913. {

  914.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  915.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename");

  916.     carla_debug("CarlaEngine::loadFile(\"%s\")", filename);

  917. 

  918.     File file(filename);

  919.     CARLA_SAFE_ASSERT_RETURN_ERR(file.existsAsFile(), "Requested file does not exist or is not a readable file");

  920. 

  921.     CarlaString baseName(file.getFileName().toRawUTF8());

  922.     CarlaString extension(file.getFileExtension().replace(".","").toLowerCase().toRawUTF8());

  923. 

  924.     // -------------------------------------------------------------------

  925. 

  926.     if (extension == "carxp" || extension == "carxs")

  927.         return loadProject(filename);

  928. 

  929.     // -------------------------------------------------------------------

  930. 

  931.     if (extension == "gig")

  932.         return addPlugin(PLUGIN_GIG, filename, baseName, baseName, 0, nullptr);

  933. 

  934.     if (extension == "sf2")

  935.         return addPlugin(PLUGIN_SF2, filename, baseName, baseName, 0, nullptr);

  936. 

  937.     if (extension == "sfz")

  938.         return addPlugin(PLUGIN_SFZ, filename, baseName, baseName, 0, nullptr);

  939. 

  940.     // -------------------------------------------------------------------

  941. 

  942.     if (extension == "aif" || extension == "aiff" || extension == "bwf" || extension == "flac" || extension == "ogg" || extension == "wav")

  943.     {

  944.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "audiofile", 0, nullptr))

  945.         {

  946.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  947.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "file", filename, true);

  948.             return true;

  949.         }

  950.         return false;

  951.     }

  952. 

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

  954. 

  955.     if (extension == "mid" || extension == "midi")

  956.     {

  957.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "midifile", 0, nullptr))

  958.         {

  959.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  960.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "file", filename, true);

  961.             return true;

  962.         }

  963.         return false;

  964.     }

  965. 

  966.     // -------------------------------------------------------------------

  967.     // ZynAddSubFX

  968. 

  969.     if (extension == "xmz" || extension == "xiz")

  970.     {

  971. #ifdef WANT_ZYNADDSUBFX

  972.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "zynaddsubfx", 0, nullptr))

  973.         {

  974.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  975.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, (extension == "xmz") ? "CarlaAlternateFile1" : "CarlaAlternateFile2", filename, true);

  976.             return true;

  977.         }

  978.         return false;

  979. #else

  980.         setLastError("This Carla build does not have ZynAddSubFX support");

  981.         return false;

  982. #endif

  983.     }

  984. 

  985.     // -------------------------------------------------------------------

  986. 

  987.     setLastError("Unknown file extension");

  988.     return false;

  989. }

  990. 

  991. bool CarlaEngine::loadProject(const char* const filename)

  992. {

  993.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  994.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename");

  995.     carla_debug("CarlaEngine::loadProject(\"%s\")", filename);

  996. 

  997.     File file(filename);

  998.     CARLA_SAFE_ASSERT_RETURN_ERR(file.existsAsFile(), "Requested file does not exist or is not a readable file");

  999. 

  1000.     XmlDocument xml(file);

  1001.     ScopedPointer<XmlElement> xmlElement(xml.getDocumentElement(true));

  1002.     CARLA_SAFE_ASSERT_RETURN_ERR(xmlElement != nullptr, "Failed to parse project file");

  1003. 

  1004.     const String& xmlType(xmlElement->getTagName());

  1005.     const bool isPreset(xmlType.equalsIgnoreCase("carla-preset"));

  1006. 

  1007.     if (! (xmlType.equalsIgnoreCase("carla-project") || isPreset))

  1008.     {

  1009.         setLastError("Not a valid Carla project or preset file");

  1010.         return false;

  1011.     }

  1012. 

  1013.     // completely load file

  1014.     xmlElement = xml.getDocumentElement(false);

  1015.     CARLA_SAFE_ASSERT_RETURN_ERR(xmlElement != nullptr, "Failed to completely parse project file");

  1016. 

  1017.     // handle plugins first

  1018.     for (XmlElement* elem = xmlElement->getFirstChildElement(); elem != nullptr; elem = elem->getNextElement())

  1019.     {

  1020.         const String& tagName(elem->getTagName());

  1021. 

  1022.         if (isPreset || tagName.equalsIgnoreCase("plugin"))

  1023.         {

  1024.             StateSave stateSave;

  1025.             stateSave.fillFromXmlElement(isPreset ? xmlElement.get() : elem);

  1026. 

  1027.             callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  1028. 

  1029.             CARLA_SAFE_ASSERT_CONTINUE(stateSave.type != nullptr);

  1030. 

  1031.             const void* extraStuff = nullptr;

  1032. 

  1033.             // check if using GIG or SF2 16outs

  1034.             static const char kUse16OutsSuffix[] = " (16 outs)";

  1035. 

  1036.             const BinaryType btype(getBinaryTypeFromFile(stateSave.binary));

  1037.             const PluginType ptype(getPluginTypeFromString(stateSave.type));

  1038. 

  1039.             if (CarlaString(stateSave.label).endsWith(kUse16OutsSuffix))

  1040.             {

  1041.                 if (ptype == PLUGIN_GIG || ptype == PLUGIN_SF2)

  1042.                     extraStuff = "true";

  1043.             }

  1044. 

  1045.             // TODO - proper find&load plugins

  1046. 

  1047.             if (addPlugin(btype, ptype, stateSave.binary, stateSave.name, stateSave.label, stateSave.uniqueId, extraStuff))

  1048.             {

  1049.                 if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  1050.                     plugin->loadStateSave(stateSave);

  1051.             }

  1052.             else

  1053.                 carla_stderr2("Failed to load a plugin, error was:\n%s", getLastError());

  1054.         }

  1055. 

  1056.         if (isPreset)

  1057.             return true;

  1058.     }

  1059. 

  1060. #ifndef BUILD_BRIDGE

  1061.     callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  1062. 

  1063.     // if we're running inside some session-manager, let them handle the connections

  1064.     if (pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY)

  1065.     {

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

  1067.             return true;

  1068.     }

  1069. 

  1070.     // now handle connections

  1071.     for (XmlElement* elem = xmlElement->getFirstChildElement(); elem != nullptr; elem = elem->getNextElement())

  1072.     {

  1073.         const String& tagName(elem->getTagName());

  1074. 

  1075.         if (tagName.equalsIgnoreCase("patchbay"))

  1076.         {

  1077.             CarlaString sourcePort, targetPort;

  1078. 

  1079.             for (XmlElement* patchElem = elem->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  1080.             {

  1081.                 const String& patchTag(patchElem->getTagName());

  1082. 

  1083.                 sourcePort.clear();

  1084.                 targetPort.clear();

  1085. 

  1086.                 if (! patchTag.equalsIgnoreCase("connection"))

  1087.                     continue;

  1088. 

  1089.                 for (XmlElement* connElem = patchElem->getFirstChildElement(); connElem != nullptr; connElem = connElem->getNextElement())

  1090.                 {

  1091.                     const String& tag(connElem->getTagName());

  1092.                     const String  text(connElem->getAllSubText().trim());

  1093. 

  1094.                     if (tag.equalsIgnoreCase("source"))

  1095.                         sourcePort = text.toRawUTF8();

  1096.                     else if (tag.equalsIgnoreCase("target"))

  1097.                         targetPort = text.toRawUTF8();

  1098.                 }

  1099. 

  1100.                 if (sourcePort.isNotEmpty() && targetPort.isNotEmpty())

  1101.                     restorePatchbayConnection(sourcePort, targetPort);

  1102.             }

  1103.             break;

  1104.         }

  1105.     }

  1106. #endif

  1107. 

  1108.     return true;

  1109. }

  1110. 

  1111. bool CarlaEngine::saveProject(const char* const filename)

  1112. {

  1113.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename");

  1114.     carla_debug("CarlaEngine::saveProject(\"%s\")", filename);

  1115. 

  1116.     MemoryOutputStream out;

  1117.     out << "<?xml version='1.0' encoding='UTF-8'?>\n";

  1118.     out << "<!DOCTYPE CARLA-PROJECT>\n";

  1119.     out << "<CARLA-PROJECT VERSION='2.0'>\n";

  1120. 

  1121.     bool firstPlugin = true;

  1122.     char strBuf[STR_MAX+1];

  1123. 

  1124.     for (uint i=0; i < pData->curPluginCount; ++i)

  1125.     {

  1126.         CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1127. 

  1128.         if (plugin != nullptr && plugin->isEnabled())

  1129.         {

  1130.             if (! firstPlugin)

  1131.                 out << "\n";

  1132. 

  1133.             strBuf[0] = '\0';

  1134. 

  1135.             plugin->getRealName(strBuf);

  1136. 

  1137.             //if (strBuf[0] != '\0')

  1138.             //    out << QString(" <!-- %1 -->\n").arg(xmlSafeString(strBuf, true));

  1139. 

  1140.             out << " <Plugin>\n";

  1141.             out << plugin->getStateSave().toString();

  1142.             out << " </Plugin>\n";

  1143. 

  1144.             firstPlugin = false;

  1145.         }

  1146.     }

  1147. 

  1148. #ifndef BUILD_BRIDGE

  1149.     bool saveConnections = true;

  1150. 

  1151.     // if we're running inside some session-manager, let them handle the connections

  1152.     if (pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY)

  1153.     {

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

  1155.             saveConnections = false;

  1156.     }

  1157. 

  1158.     if (saveConnections)

  1159.     {

  1160.         if (const char* const* const patchbayConns = getPatchbayConnections())

  1161.         {

  1162.             if (! firstPlugin)

  1163.                 out << "\n";

  1164. 

  1165.             out << " <Patchbay>\n";

  1166. 

  1167.             for (int i=0; patchbayConns[i] != nullptr && patchbayConns[i+1] != nullptr; ++i, ++i )

  1168.             {

  1169.                 const char* const connSource(patchbayConns[i]);

  1170.                 const char* const connTarget(patchbayConns[i+1]);

  1171. 

  1172.                 CARLA_SAFE_ASSERT_CONTINUE(connSource != nullptr && connSource[0] != '\0');

  1173.                 CARLA_SAFE_ASSERT_CONTINUE(connTarget != nullptr && connTarget[0] != '\0');

  1174. 

  1175.                 out << "  <Connection>\n";

  1176.                 out << "   <Source>" << connSource << "</Source>\n";

  1177.                 out << "   <Target>" << connTarget << "</Target>\n";

  1178.                 out << "  </Connection>\n";

  1179.             }

  1180. 

  1181.             out << " </Patchbay>\n";

  1182.         }

  1183.     }

  1184. #endif

  1185. 

  1186.     out << "</CARLA-PROJECT>\n";

  1187. 

  1188.     File file(filename);

  1189. 

  1190.     if (file.replaceWithData(out.getData(), out.getDataSize()))

  1191.         return true;

  1192. 

  1193.     setLastError("Failed to write file");

  1194.     return false;

  1195. }

  1196. 

  1197. // -----------------------------------------------------------------------

  1198. // Information (base)

  1199. 

  1200. uint CarlaEngine::getHints() const noexcept

  1201. {

  1202.     return pData->hints;

  1203. }

  1204. 

  1205. uint32_t CarlaEngine::getBufferSize() const noexcept

  1206. {

  1207.     return pData->bufferSize;

  1208. }

  1209. 

  1210. double CarlaEngine::getSampleRate() const noexcept

  1211. {

  1212.     return pData->sampleRate;

  1213. }

  1214. 

  1215. const char* CarlaEngine::getName() const noexcept

  1216. {

  1217.     return pData->name;

  1218. }

  1219. 

  1220. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1221. {

  1222.     return pData->options.processMode;

  1223. }

  1224. 

  1225. const EngineOptions& CarlaEngine::getOptions() const noexcept

  1226. {

  1227.     return pData->options;

  1228. }

  1229. 

  1230. const EngineTimeInfo& CarlaEngine::getTimeInfo() const noexcept

  1231. {

  1232.     return pData->timeInfo;

  1233. }

  1234. 

  1235. // -----------------------------------------------------------------------

  1236. // Information (peaks)

  1237. 

  1238. float CarlaEngine::getInputPeak(const uint pluginId, const bool isLeft) const noexcept

  1239. {

  1240.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount, 0.0f);

  1241. 

  1242.     return pData->plugins[pluginId].insPeak[isLeft ? 0 : 1];

  1243. }

  1244. 

  1245. float CarlaEngine::getOutputPeak(const uint pluginId, const bool isLeft) const noexcept

  1246. {

  1247.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount, 0.0f);

  1248. 

  1249.     return pData->plugins[pluginId].outsPeak[isLeft ? 0 : 1];

  1250. }

  1251. 

  1252. // -----------------------------------------------------------------------

  1253. // Callback

  1254. 

  1255. void CarlaEngine::callback(const EngineCallbackOpcode action, const uint pluginId, const int value1, const int value2, const float value3, const char* const valueStr) noexcept

  1256. {

  1257.     carla_debug("CarlaEngine::callback(%i:%s, %i, %i, %i, %f, \"%s\")", action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valueStr);

  1258. 

  1259. #ifdef BUILD_BRIDGE

  1260.     if (pData->isIdling)

  1261. #else

  1262.     if (pData->isIdling && action != ENGINE_CALLBACK_PATCHBAY_CLIENT_DATA_CHANGED)

  1263. #endif

  1264.     {

  1265.         carla_stdout("callback while idling (%i:%s, %i, %i, %i, %f, \"%s\")", action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valueStr);

  1266.     }

  1267. 

  1268.     if (action == ENGINE_CALLBACK_IDLE)

  1269.     {

  1270.         ++pData->isIdling;

  1271.     }

  1272. #ifdef BUILD_BRIDGE

  1273.     else if (pData->oscData != nullptr)

  1274.     {

  1275.         switch (action)

  1276.         {

  1277.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED:

  1278.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  1279.             oscSend_bridge_parameter_value(static_cast<uint>(value1), value3);

  1280.             break;

  1281.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED:

  1282.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  1283.             oscSend_bridge_default_value(static_cast<uint>(value1), value3);

  1284.             break;

  1285.         case ENGINE_CALLBACK_PROGRAM_CHANGED:

  1286.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  1287.             oscSend_bridge_current_program(value1);

  1288.             break;

  1289.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED:

  1290.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  1291.             oscSend_bridge_current_midi_program(value1);

  1292.             break;

  1293.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  1294.             if (value1 != 1)

  1295.                 oscSend_bridge_configure("CarlaBridgeHideGUI", "");

  1296.             break;

  1297.         default:

  1298.             break;

  1299.         }

  1300.     }

  1301. #endif

  1302. 

  1303.     if (pData->callback != nullptr)

  1304.     {

  1305.         try {

  1306.             pData->callback(pData->callbackPtr, action, pluginId, value1, value2, value3, valueStr);

  1307.         } CARLA_SAFE_EXCEPTION("callback");

  1308.     }

  1309. 

  1310.     if (action == ENGINE_CALLBACK_IDLE)

  1311.         --pData->isIdling;

  1312. }

  1313. 

  1314. void CarlaEngine::setCallback(const EngineCallbackFunc func, void* const ptr) noexcept

  1315. {

  1316.     carla_debug("CarlaEngine::setCallback(%p, %p)", func, ptr);

  1317. 

  1318.     pData->callback    = func;

  1319.     pData->callbackPtr = ptr;

  1320. }

  1321. 

  1322. // -----------------------------------------------------------------------

  1323. // File Callback

  1324. 

  1325. const char* CarlaEngine::runFileCallback(const FileCallbackOpcode action, const bool isDir, const char* const title, const char* const filter) noexcept

  1326. {

  1327.     CARLA_SAFE_ASSERT_RETURN(title != nullptr && title[0] != '\0', nullptr);

  1328.     CARLA_SAFE_ASSERT_RETURN(filter != nullptr, nullptr);

  1329.     carla_debug("CarlaEngine::runFileCallback(%i:%s, %s, \"%s\", \"%s\")", action, FileCallbackOpcode2Str(action), bool2str(isDir), title, filter);

  1330. 

  1331.     const char* ret = nullptr;

  1332. 

  1333.     if (pData->fileCallback != nullptr)

  1334.     {

  1335.         try {

  1336.             ret = pData->fileCallback(pData->fileCallbackPtr, action, isDir, title, filter);

  1337.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1338.     }

  1339. 

  1340.     return ret;

  1341. }

  1342. 

  1343. void CarlaEngine::setFileCallback(const FileCallbackFunc func, void* const ptr) noexcept

  1344. {

  1345.     carla_debug("CarlaEngine::setFileCallback(%p, %p)", func, ptr);

  1346. 

  1347.     pData->fileCallback    = func;

  1348.     pData->fileCallbackPtr = ptr;

  1349. }

  1350. 

  1351. // -----------------------------------------------------------------------

  1352. // Transport

  1353. 

  1354. void CarlaEngine::transportPlay() noexcept

  1355. {

  1356.     pData->time.playing = true;

  1357. }

  1358. 

  1359. void CarlaEngine::transportPause() noexcept

  1360. {

  1361.     pData->time.playing = false;

  1362. }

  1363. 

  1364. void CarlaEngine::transportRelocate(const uint64_t frame) noexcept

  1365. {

  1366.     pData->time.frame = frame;

  1367. }

  1368. 

  1369. // -----------------------------------------------------------------------

  1370. // Error handling

  1371. 

  1372. const char* CarlaEngine::getLastError() const noexcept

  1373. {

  1374.     return pData->lastError;

  1375. }

  1376. 

  1377. void CarlaEngine::setLastError(const char* const error) const noexcept

  1378. {

  1379.     pData->lastError = error;

  1380. }

  1381. 

  1382. void CarlaEngine::setAboutToClose() noexcept

  1383. {

  1384.     carla_debug("CarlaEngine::setAboutToClose()");

  1385. 

  1386.     pData->aboutToClose = true;

  1387. }

  1388. 

  1389. // -----------------------------------------------------------------------

  1390. // Global options

  1391. 

  1392. void CarlaEngine::setOption(const EngineOption option, const int value, const char* const valueStr) noexcept

  1393. {

  1394.     carla_debug("CarlaEngine::setOption(%i:%s, %i, \"%s\")", option, EngineOption2Str(option), value, valueStr);

  1395. 

  1396.     if (isRunning() && (option == ENGINE_OPTION_PROCESS_MODE || option == ENGINE_OPTION_AUDIO_NUM_PERIODS || option == ENGINE_OPTION_AUDIO_DEVICE))

  1397.         return carla_stderr("CarlaEngine::setOption(%i:%s, %i, \"%s\") - Cannot set this option while engine is running!", option, EngineOption2Str(option), value, valueStr);

  1398. 

  1399.     switch (option)

  1400.     {

  1401.     case ENGINE_OPTION_DEBUG:

  1402.     case ENGINE_OPTION_NSM_INIT:

  1403.         break;

  1404. 

  1405.     case ENGINE_OPTION_PROCESS_MODE:

  1406.         CARLA_SAFE_ASSERT_RETURN(value >= ENGINE_PROCESS_MODE_SINGLE_CLIENT && value <= ENGINE_PROCESS_MODE_BRIDGE,);

  1407.         pData->options.processMode = static_cast<EngineProcessMode>(value);

  1408.         break;

  1409. 

  1410.     case ENGINE_OPTION_TRANSPORT_MODE:

  1411.         CARLA_SAFE_ASSERT_RETURN(value >= ENGINE_TRANSPORT_MODE_INTERNAL && value <= ENGINE_TRANSPORT_MODE_BRIDGE,);

  1412.         pData->options.transportMode = static_cast<EngineTransportMode>(value);

  1413.         break;

  1414. 

  1415.     case ENGINE_OPTION_FORCE_STEREO:

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

  1417.         pData->options.forceStereo = (value != 0);

  1418.         break;

  1419. 

  1420.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

  1422.         pData->options.preferPluginBridges = (value != 0);

  1423.         break;

  1424. 

  1425.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

  1427.         pData->options.preferUiBridges = (value != 0);

  1428.         break;

  1429. 

  1430.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

  1432.         pData->options.uisAlwaysOnTop = (value != 0);

  1433.         break;

  1434. 

  1435.     case ENGINE_OPTION_MAX_PARAMETERS:

  1436.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  1437.         pData->options.maxParameters = static_cast<uint>(value);

  1438.         break;

  1439. 

  1440.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1441.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  1442.         pData->options.uiBridgesTimeout = static_cast<uint>(value);

  1443.         break;

  1444. 

  1445.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

  1447.         pData->options.audioNumPeriods = static_cast<uint>(value);

  1448.         break;

  1449. 

  1450.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1451.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

  1452.         pData->options.audioBufferSize = static_cast<uint>(value);

  1453.         break;

  1454. 

  1455.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1456.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

  1457.         pData->options.audioSampleRate = static_cast<uint>(value);

  1458.         break;

  1459. 

  1460.     case ENGINE_OPTION_AUDIO_DEVICE:

  1461.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1462. 

  1463.         if (pData->options.audioDevice != nullptr)

  1464.             delete[] pData->options.audioDevice;

  1465. 

  1466.         pData->options.audioDevice = carla_strdup_safe(valueStr);

  1467.         break;

  1468. 

  1469.     case ENGINE_OPTION_PATH_BINARIES:

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

  1471. 

  1472.         if (pData->options.binaryDir != nullptr)

  1473.             delete[] pData->options.binaryDir;

  1474. 

  1475.         pData->options.binaryDir = carla_strdup_safe(valueStr);

  1476.         break;

  1477. 

  1478.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1480. 

  1481.         if (pData->options.resourceDir != nullptr)

  1482.             delete[] pData->options.resourceDir;

  1483. 

  1484.         pData->options.resourceDir = carla_strdup_safe(valueStr);

  1485.         break;

  1486. 

  1487.     case ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1490.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

  1491.         pData->options.frontendWinId = static_cast<uintptr_t>(winId);

  1492.         break;

  1493.     }

  1494. }

  1495. 

  1496. // -----------------------------------------------------------------------

  1497. // OSC Stuff

  1498. 

  1499. #ifdef BUILD_BRIDGE

  1500. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1501. {

  1502.     return (pData->oscData != nullptr);

  1503. }

  1504. #else

  1505. bool CarlaEngine::isOscControlRegistered() const noexcept

  1506. {

  1507.     return pData->osc.isControlRegistered();

  1508. }

  1509. #endif

  1510. 

  1511. void CarlaEngine::idleOsc() const noexcept

  1512. {

  1513.     pData->osc.idle();

  1514. }

  1515. 

  1516. const char* CarlaEngine::getOscServerPathTCP() const noexcept

  1517. {

  1518.     return pData->osc.getServerPathTCP();

  1519. }

  1520. 

  1521. const char* CarlaEngine::getOscServerPathUDP() const noexcept

  1522. {

  1523.     return pData->osc.getServerPathUDP();

  1524. }

  1525. 

  1526. #ifdef BUILD_BRIDGE

  1527. void CarlaEngine::setOscBridgeData(CarlaOscData* const oscData) const noexcept

  1528. {

  1529.     pData->oscData = oscData;

  1530. }

  1531. #endif

  1532. 

  1533. // -----------------------------------------------------------------------

  1534. // Helper functions

  1535. 

  1536. EngineEvent* CarlaEngine::getInternalEventBuffer(const bool isInput) const noexcept

  1537. {

  1538.     return isInput ? pData->events.in : pData->events.out;

  1539. }

  1540. 

  1541. void CarlaEngine::registerEnginePlugin(const uint id, CarlaPlugin* const plugin) noexcept

  1542. {

  1543.     CARLA_SAFE_ASSERT_RETURN(id == pData->curPluginCount,);

  1544.     carla_debug("CarlaEngine::registerEnginePlugin(%i, %p)", id, plugin);

  1545. 

  1546.     pData->plugins[id].plugin = plugin;

  1547. }

  1548. 

  1549. // -----------------------------------------------------------------------

  1550. // Internal stuff

  1551. 

  1552. void CarlaEngine::bufferSizeChanged(const uint32_t newBufferSize)

  1553. {

  1554.     carla_debug("CarlaEngine::bufferSizeChanged(%i)", newBufferSize);

  1555. 

  1556. #ifndef BUILD_BRIDGE

  1557.     pData->graph.setBufferSize(newBufferSize);

  1558. #endif

  1559. 

  1560.     for (uint i=0; i < pData->curPluginCount; ++i)

  1561.     {

  1562.         CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1563. 

  1564.         if (plugin != nullptr && plugin->isEnabled())

  1565.             plugin->bufferSizeChanged(newBufferSize);

  1566.     }

  1567. 

  1568.     callback(ENGINE_CALLBACK_BUFFER_SIZE_CHANGED, 0, static_cast<int>(newBufferSize), 0, 0.0f, nullptr);

  1569. }

  1570. 

  1571. void CarlaEngine::sampleRateChanged(const double newSampleRate)

  1572. {

  1573.     carla_debug("CarlaEngine::sampleRateChanged(%g)", newSampleRate);

  1574. 

  1575. #ifndef BUILD_BRIDGE

  1576.     pData->graph.setSampleRate(newSampleRate);

  1577. #endif

  1578. 

  1579.     for (uint i=0; i < pData->curPluginCount; ++i)

  1580.     {

  1581.         CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1582. 

  1583.         if (plugin != nullptr && plugin->isEnabled())

  1584.             plugin->sampleRateChanged(newSampleRate);

  1585.     }

  1586. 

  1587.     callback(ENGINE_CALLBACK_SAMPLE_RATE_CHANGED, 0, 0, 0, static_cast<float>(newSampleRate), nullptr);

  1588. }

  1589. 

  1590. void CarlaEngine::offlineModeChanged(const bool isOfflineNow)

  1591. {

  1592.     carla_debug("CarlaEngine::offlineModeChanged(%s)", bool2str(isOfflineNow));

  1593. 

  1594. #ifndef BUILD_BRIDGE

  1595.     pData->graph.setOffline(isOfflineNow);

  1596. #endif

  1597. 

  1598.     for (uint i=0; i < pData->curPluginCount; ++i)

  1599.     {

  1600.         CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1601. 

  1602.         if (plugin != nullptr && plugin->isEnabled())

  1603.             plugin->offlineModeChanged(isOfflineNow);

  1604.     }

  1605. }

  1606. 

  1607. void CarlaEngine::runPendingRtEvents() noexcept

  1608. {

  1609.     pData->doNextPluginAction(true);

  1610. 

  1611.     if (pData->time.playing)

  1612.         pData->time.frame += pData->bufferSize;

  1613. 

  1614.     if (pData->options.transportMode == ENGINE_TRANSPORT_MODE_INTERNAL)

  1615.     {

  1616.         pData->timeInfo.playing = pData->time.playing;

  1617.         pData->timeInfo.frame   = pData->time.frame;

  1618.     }

  1619. }

  1620. 

  1621. void CarlaEngine::setPluginPeaks(const uint pluginId, float const inPeaks[2], float const outPeaks[2]) noexcept

  1622. {

  1623.     EnginePluginData& pluginData(pData->plugins[pluginId]);

  1624. 

  1625.     pluginData.insPeak[0]  = inPeaks[0];

  1626.     pluginData.insPeak[1]  = inPeaks[1];

  1627.     pluginData.outsPeak[0] = outPeaks[0];

  1628.     pluginData.outsPeak[1] = outPeaks[1];

  1629. }

  1630. 

  1631. // -----------------------------------------------------------------------

  1632. 

  1633. CARLA_BACKEND_END_NAMESPACE