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

2367 lines
91KB
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.  * - patchbayDisconnect should return false sometimes

  25.  */

  26. 

  27. #include "CarlaEngineInternal.hpp"

  28. #include "CarlaPlugin.hpp"

  29. 

  30. #include "CarlaBackendUtils.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. // -----------------------------------------------------------------------

  47. 

  48. CARLA_BACKEND_START_NAMESPACE

  49. 

  50. #if 0

  51. } // Fix editor indentation

  52. #endif

  53. 

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

  55. // Carla Engine

  56. 

  57. CarlaEngine::CarlaEngine()

  58.     : pData(new ProtectedData(this))

  59. {

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

  61. }

  62. 

  63. CarlaEngine::~CarlaEngine()

  64. {

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

  66. 

  67.     delete pData;

  68. }

  69. 

  70. // -----------------------------------------------------------------------

  71. // Static calls

  72. 

  73. uint CarlaEngine::getDriverCount()

  74. {

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

  76. 

  77.     uint count = 0;

  78. 

  79.     if (jackbridge_is_ok())

  80.         count += 1;

  81. 

  82. #ifndef BUILD_BRIDGE

  83.     count += getRtAudioApiCount();

  84. # ifdef HAVE_JUCE

  85.     count += getJuceApiCount();

  86. # endif

  87. #endif

  88. 

  89.     return count;

  90. }

  91. 

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

  93. {

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

  95. 

  96.     uint index(index2);

  97. 

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

  99.         return "JACK";

  100. 

  101. #ifndef BUILD_BRIDGE

  102.     if (index < getRtAudioApiCount())

  103.         return getRtAudioApiName(index);

  104. 

  105.     index -= getRtAudioApiCount();

  106. 

  107. # ifdef HAVE_JUCE

  108.     if (index < getJuceApiCount())

  109.         return getJuceApiName(index);

  110. # endif

  111. #endif

  112. 

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

  114.     return nullptr;

  115. }

  116. 

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

  118. {

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

  120. 

  121.     uint index(index2);

  122. 

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

  124.     {

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

  126.         return ret;

  127.     }

  128. 

  129. #ifndef BUILD_BRIDGE

  130.     if (index < getRtAudioApiCount())

  131.         return getRtAudioApiDeviceNames(index);

  132. 

  133.     index -= getRtAudioApiCount();

  134. 

  135. # ifdef HAVE_JUCE

  136.     if (index < getJuceApiCount())

  137.         return getJuceApiDeviceNames(index);

  138. # endif

  139. #endif

  140. 

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

  142.     return nullptr;

  143. }

  144. 

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

  146. {

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

  148. 

  149.     uint index(index2);

  150. 

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

  152.     {

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

  154.         static EngineDriverDeviceInfo devInfo;

  155.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  156.         devInfo.bufferSizes = bufSizes;

  157.         devInfo.sampleRates = nullptr;

  158.         return &devInfo;

  159.     }

  160. 

  161. #ifndef BUILD_BRIDGE

  162.     if (index < getRtAudioApiCount())

  163.         return getRtAudioDeviceInfo(index, deviceName);

  164. 

  165.     index -= getRtAudioApiCount();

  166. 

  167. # ifdef HAVE_JUCE

  168.     if (index < getJuceApiCount())

  169.         return getJuceDeviceInfo(index, deviceName);

  170. # endif

  171. #endif

  172. 

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

  174.     return nullptr;

  175. }

  176. 

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

  178. {

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

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

  181. 

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

  183.         return newJack();

  184. 

  185. #ifndef BUILD_BRIDGE

  186.     // -------------------------------------------------------------------

  187.     // common

  188. 

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

  190.         return newRtAudio(AUDIO_API_JACK);

  191. 

  192.     // -------------------------------------------------------------------

  193.     // linux

  194. 

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

  196.     {

  197. # ifdef HAVE_JUCE

  198.         return newJuce(AUDIO_API_ALSA);

  199. # else

  200.         return newRtAudio(AUDIO_API_ALSA);

  201. # endif

  202.     }

  203. 

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

  205.         return newRtAudio(AUDIO_API_OSS);

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

  207.         return newRtAudio(AUDIO_API_PULSE);

  208. 

  209.     // -------------------------------------------------------------------

  210.     // macos

  211. 

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

  213.     {

  214. # ifdef HAVE_JUCE

  215.         return newJuce(AUDIO_API_CORE);

  216. # else

  217.         return newRtAudio(AUDIO_API_CORE);

  218. # endif

  219.     }

  220. 

  221.     // -------------------------------------------------------------------

  222.     // windows

  223. 

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

  225.     {

  226. # ifdef HAVE_JUCE

  227.         return newJuce(AUDIO_API_ASIO);

  228. # else

  229.         return newRtAudio(AUDIO_API_ASIO);

  230. # endif

  231.     }

  232. 

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

  234.     {

  235. # ifdef HAVE_JUCE

  236.         return newJuce(AUDIO_API_DS);

  237. # else

  238.         return newRtAudio(AUDIO_API_DS);

  239. # endif

  240.     }

  241. #endif

  242. 

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

  244.     return nullptr;

  245. }

  246. 

  247. // -----------------------------------------------------------------------

  248. // Maximum values

  249. 

  250. uint CarlaEngine::getMaxClientNameSize() const noexcept

  251. {

  252.     return STR_MAX/2;

  253. }

  254. 

  255. uint CarlaEngine::getMaxPortNameSize() const noexcept

  256. {

  257.     return STR_MAX;

  258. }

  259. 

  260. uint CarlaEngine::getCurrentPluginCount() const noexcept

  261. {

  262.     return pData->curPluginCount;

  263. }

  264. 

  265. uint CarlaEngine::getMaxPluginNumber() const noexcept

  266. {

  267.     return pData->maxPluginNumber;

  268. }

  269. 

  270. // -----------------------------------------------------------------------

  271. // Virtual, per-engine type calls

  272. 

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

  274. {

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

  276. 

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

  278.         return false;

  279. 

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

  281.     return true;

  282. }

  283. 

  284. bool CarlaEngine::close()

  285. {

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

  287. 

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

  289.     {

  290.         pData->aboutToClose = true;

  291.         removeAllPlugins();

  292.     }

  293. 

  294. #ifndef BUILD_BRIDGE

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

  296.         oscSend_control_exit();

  297. #endif

  298. 

  299.     pData->close();

  300. 

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

  302.     return true;

  303. }

  304. 

  305. void CarlaEngine::idle() noexcept

  306. {

  307.     CARLA_SAFE_ASSERT_RETURN(pData->nextAction.opcode == kEnginePostActionNull,); // TESTING, remove later

  308.     CARLA_SAFE_ASSERT_RETURN(pData->nextPluginId == pData->maxPluginNumber,);     // TESTING, remove later

  309.     CARLA_SAFE_ASSERT_RETURN(pData->plugins != nullptr,); // this one too maybe

  310. 

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

  312.     {

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

  314. 

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

  316.         {

  317.             try {

  318.                 plugin->idle();

  319.             } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin idle");

  320.         }

  321.     }

  322. 

  323.     pData->osc.idle();

  324. }

  325. 

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

  327. {

  328.     return new CarlaEngineClient(*this);

  329. }

  330. 

  331. // -----------------------------------------------------------------------

  332. // Plugin management

  333. 

  334. 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)

  335. {

  336.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #10)");

  337.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId <= pData->maxPluginNumber, "Invalid engine internal data (err #11)");

  338.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #12)");

  339.     CARLA_SAFE_ASSERT_RETURN_ERR(btype != BINARY_NONE, "Invalid plugin params (err #1)");

  340.     CARLA_SAFE_ASSERT_RETURN_ERR(ptype != PLUGIN_NONE, "Invalid plugin params (err #2)");

  341.     CARLA_SAFE_ASSERT_RETURN_ERR((filename != nullptr && filename[0] != '\0') || (label != nullptr && label[0] != '\0'), "Invalid plugin params (err #3)");

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

  343. 

  344.     uint id;

  345. 

  346. #ifndef BUILD_BRIDGE

  347.     CarlaPlugin* oldPlugin = nullptr;

  348. 

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

  350.     {

  351.         id = pData->nextPluginId;

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

  353. 

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

  355. 

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

  357.     }

  358.     else

  359. #endif

  360.     {

  361.         id = pData->curPluginCount;

  362. 

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

  364.         {

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

  366.             return false;

  367.         }

  368. 

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

  370.     }

  371. 

  372.     CarlaPlugin::Initializer initializer = {

  373.         this,

  374.         id,

  375.         filename,

  376.         name,

  377.         label,

  378.         uniqueId

  379.     };

  380. 

  381.     CarlaPlugin* plugin = nullptr;

  382. 

  383. #ifndef BUILD_BRIDGE

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

  385. 

  386.     if (bridgeBinary.isNotEmpty())

  387.     {

  388. # ifndef CARLA_OS_WIN

  389.         if (btype == BINARY_NATIVE)

  390.         {

  391.             bridgeBinary += OS_SEP_STR "carla-bridge-native";

  392.         }

  393.         else

  394. # endif

  395.         {

  396.             switch (btype)

  397.             {

  398.             case BINARY_POSIX32:

  399.                 bridgeBinary += OS_SEP_STR "carla-bridge-posix32";

  400.                 break;

  401.             case BINARY_POSIX64:

  402.                 bridgeBinary += OS_SEP_STR "carla-bridge-posix64";

  403.                 break;

  404.             case BINARY_WIN32:

  405.                 bridgeBinary += OS_SEP_STR "carla-bridge-win32.exe";

  406.                 break;

  407.             case BINARY_WIN64:

  408.                 bridgeBinary += OS_SEP_STR "carla-bridge-win64.exe";

  409.                 break;

  410.             default:

  411.                 bridgeBinary.clear();

  412.                 break;

  413.             }

  414.         }

  415. 

  416.         File file(bridgeBinary.buffer());

  417. 

  418.         if (! file.existsAsFile())

  419.             bridgeBinary.clear();

  420.     }

  421. 

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

  423.     {

  424.         if (bridgeBinary.isNotEmpty())

  425.         {

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

  427.         }

  428. # ifdef CARLA_OS_LINUX

  429.         else if (btype == BINARY_WIN32)

  430.         {

  431.             // fallback to dssi-vst

  432.             File file(filename);

  433. 

  434.             CarlaString label2(file.getFullPathName().toRawUTF8());

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

  436. 

  437.             CarlaPlugin::Initializer init2 = {

  438.                 this,

  439.                 id,

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

  441.                 name,

  442.                 label2,

  443.                 uniqueId

  444.             };

  445. 

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

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

  448. 

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

  450. 

  451.             if (oldVstPath != nullptr)

  452.                 carla_setenv("VST_PATH", oldVstPath);

  453.         }

  454. # endif

  455.         else

  456.         {

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

  458.             return false;

  459.         }

  460.     }

  461.     else

  462. #endif // ! BUILD_BRIDGE

  463.     {

  464.         bool use16Outs;

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

  466. 

  467.         switch (ptype)

  468.         {

  469.         case PLUGIN_NONE:

  470.             break;

  471. 

  472.         case PLUGIN_INTERNAL:

  473.             if (std::strcmp(label, "Csound") == 0)

  474.             {

  475.                 plugin = CarlaPlugin::newCsound(initializer);

  476.             }

  477.             else if (std::strcmp(label, "FluidSynth") == 0)

  478.             {

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

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

  481.             }

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

  483.             {

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

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

  486.             }

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

  488.             {

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

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

  491.             }

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

  493.             {

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

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

  496.             }

  497.             else

  498.             {

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

  500.             }

  501.             break;

  502. 

  503.         case PLUGIN_LADSPA:

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

  505.             break;

  506. 

  507.         case PLUGIN_DSSI:

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

  509.             break;

  510. 

  511.         case PLUGIN_LV2:

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

  513.             break;

  514. 

  515.         case PLUGIN_VST:

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

  517.             break;

  518. 

  519.         case PLUGIN_VST3:

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

  521.             break;

  522. 

  523.         case PLUGIN_AU:

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

  525.             break;

  526. 

  527.         case PLUGIN_JACK:

  528.             plugin = CarlaPlugin::newJACK(initializer);

  529.             break;

  530. 

  531.         case PLUGIN_REWIRE:

  532.             plugin = CarlaPlugin::newReWire(initializer);

  533.             break;

  534. 

  535.         case PLUGIN_FILE_CSD:

  536.             plugin = CarlaPlugin::newFileCSD(initializer);

  537.             break;

  538. 

  539.         case PLUGIN_FILE_GIG:

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

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

  542.             break;

  543. 

  544.         case PLUGIN_FILE_SF2:

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

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

  547.             break;

  548. 

  549.         case PLUGIN_FILE_SFZ:

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

  551.             break;

  552.         }

  553.     }

  554. 

  555.     if (plugin == nullptr)

  556.     {

  557. #ifndef BUILD_BRIDGE

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

  559. #endif

  560.         return false;

  561.     }

  562. 

  563.     plugin->registerToOscClient();

  564. 

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

  566.     pluginData.plugin      = plugin;

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

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

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

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

  571. 

  572. #ifndef BUILD_BRIDGE

  573.     if (oldPlugin != nullptr)

  574.     {

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

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

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

  578. 

  579.         delete oldPlugin;

  580.         callback(ENGINE_CALLBACK_RELOAD_ALL, id, 0, 0, 0.0f, plugin->getName());

  581. 

  582.         if (wasActive)

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

  584. 

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

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

  587. 

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

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

  590.     }

  591.     else

  592. #endif

  593.     {

  594.         ++pData->curPluginCount;

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

  596. 

  597.         //if (pData->curPluginCount == 1 && pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  598.         //    callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_DATA_CHANGED, 0, PATCHBAY_ICON_CARLA, 0, 0.0f, nullptr);

  599.     }

  600. 

  601.     return true;

  602. }

  603. 

  604. 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)

  605. {

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

  607. }

  608. 

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

  610. {

  611.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #14)");

  612.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data (err #15)");

  613.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #16)");

  614.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id (err #1)");

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

  616. 

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

  618. 

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

  620.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data (err #17)");

  621. 

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

  623. 

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

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

  626. 

  627. #ifndef BUILD_BRIDGE

  628.     if (isOscControlRegistered())

  629.         oscSend_control_remove_plugin(id);

  630. #endif

  631. 

  632.     delete plugin;

  633. 

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

  635.         pData->thread.startThread();

  636. 

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

  638.     return true;

  639. }

  640. 

  641. bool CarlaEngine::removeAllPlugins()

  642. {

  643.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #18)");

  644.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId == pData->maxPluginNumber, "Invalid engine internal data (err #19)");

  645.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #20)");

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

  647. 

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

  649.         return true;

  650. 

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

  652. 

  653.     const bool lockWait(isRunning());

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

  655. 

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

  657. 

  658.     for (uint i=0; i < pData->maxPluginNumber; ++i)

  659.     {

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

  661. 

  662.         if (pluginData.plugin != nullptr)

  663.         {

  664.             delete pluginData.plugin;

  665.             pluginData.plugin = nullptr;

  666.         }

  667. 

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

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

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

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

  672. 

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

  674.     }

  675. 

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

  677.         pData->thread.startThread();

  678. 

  679.     return true;

  680. }

  681. 

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

  683. {

  684.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->plugins != nullptr, "Invalid engine internal data (err #21)");

  685.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->curPluginCount != 0, "Invalid engine internal data (err #22)");

  686.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #23)");

  687.     CARLA_SAFE_ASSERT_RETURN_ERRN(id < pData->curPluginCount, "Invalid plugin Id (err #2)");

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

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

  690. 

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

  692. 

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

  694.     CARLA_SAFE_ASSERT_RETURN_ERRN(plugin->getId() == id, "Invalid engine internal data (err #24)");

  695. 

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

  697.     {

  698.         plugin->setName(name);

  699.         return name;

  700.     }

  701. 

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

  703.     return nullptr;

  704. }

  705. 

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

  707. {

  708.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #25)");

  709.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data (err #26)");

  710.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #27)");

  711.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id (err #3)");

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

  713. 

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

  715. 

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

  717.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data (err #28)");

  718. 

  719.     char label[STR_MAX+1];

  720.     carla_zeroChar(label, STR_MAX+1);

  721.     plugin->getLabel(label);

  722. 

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

  724. 

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

  726.         return false;

  727. 

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

  729. 

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

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

  732. 

  733.     return true;

  734. }

  735. 

  736. bool CarlaEngine::replacePlugin(const uint id)

  737. {

  738.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #29)");

  739.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data (err #30)");

  740.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #31)");

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

  742. 

  743.     // might use this to reset

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

  745.     {

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

  747.         return true;

  748.     }

  749. 

  750.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id (err #4)");

  751. 

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

  753. 

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

  755.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data (err #32)");

  756. 

  757.     pData->nextPluginId = id;

  758. 

  759.     return true;

  760. }

  761. 

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

  763. {

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

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

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

  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 (err #5)");

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

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

  771. 

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

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

  774. 

  775.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginA != nullptr, "Could not find plugin to switch (err #1)");

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

  777.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginA->getId() == idA, "Invalid engine internal data (err #36)");

  778.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginB->getId() == idB, "Invalid engine internal data (err #37)");

  779. 

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

  781. 

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

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

  784. 

  785. #ifndef BUILD_BRIDGE // TODO

  786.     //if (isOscControlRegistered())

  787.     //    oscSend_control_switch_plugins(idA, idB);

  788. #endif

  789. 

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

  791.         pData->thread.startThread();

  792. 

  793.     return true;

  794. }

  795. 

  796. CarlaPlugin* CarlaEngine::getPlugin(const uint id) const

  797. {

  798.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->plugins != nullptr, "Invalid engine internal data (err #38)");

  799.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->curPluginCount != 0, "Invalid engine internal data (err #39)");

  800.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #40)");

  801.     CARLA_SAFE_ASSERT_RETURN_ERRN(id < pData->curPluginCount, "Invalid plugin Id (err #7)");

  802. 

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

  804. }

  805. 

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

  807. {

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

  809. }

  810. 

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

  812. {

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

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

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

  816. 

  817.     CarlaString sname;

  818.     sname = name;

  819. 

  820.     if (sname.isEmpty())

  821.     {

  822.         sname = "(No name)";

  823.         return sname.dup();

  824.     }

  825. 

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

  827. 

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

  829.         return sname.dup();

  830. 

  831.     sname.truncate(maxNameSize);

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

  833. 

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

  835.     {

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

  837. 

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

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

  840.         {

  841.             if (sname != pluginName)

  842.                 continue;

  843.         }

  844. 

  845.         // Check if string has already been modified

  846.         {

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

  848. 

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

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

  851.             {

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

  853. 

  854.                 if (number == 9)

  855.                 {

  856.                     // next number is 10, 2 digits

  857.                     sname.truncate(len-4);

  858.                     sname += " (10)";

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

  860.                 }

  861.                 else

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

  863. 

  864.                 continue;

  865.             }

  866. 

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

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

  869.             {

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

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

  872. 

  873.                 if (n2 == '9')

  874.                 {

  875.                     n2 = '0';

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

  877.                 }

  878.                 else

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

  880. 

  881.                 sname[len-2] = n2;

  882.                 sname[len-3] = n3;

  883. 

  884.                 continue;

  885.             }

  886.         }

  887. 

  888.         // Modify string if not

  889.         sname += " (2)";

  890.     }

  891. 

  892.     return sname.dup();

  893. }

  894. 

  895. // -----------------------------------------------------------------------

  896. // Project management

  897. 

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

  899. {

  900.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename (err #1)");

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

  902. 

  903.     File file(filename);

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

  905. 

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

  907.     CarlaString extension(file.getFileExtension().toRawUTF8());

  908.     extension.toLower();

  909. 

  910.     // -------------------------------------------------------------------

  911. 

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

  913.         return loadProject(filename);

  914. 

  915.     // -------------------------------------------------------------------

  916. 

  917.     if (extension == "csd")

  918.         return addPlugin(PLUGIN_FILE_CSD, filename, baseName, baseName, 0, nullptr);

  919. 

  920.     if (extension == "gig")

  921.         return addPlugin(PLUGIN_FILE_GIG, filename, baseName, baseName, 0, nullptr);

  922. 

  923.     if (extension == "sf2")

  924.         return addPlugin(PLUGIN_FILE_SF2, filename, baseName, baseName, 0, nullptr);

  925. 

  926.     if (extension == "sfz")

  927.         return addPlugin(PLUGIN_FILE_SFZ, filename, baseName, baseName, 0, nullptr);

  928. 

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

  930. 

  931.     if (extension == "aiff" || extension == "flac" || extension == "oga" || extension == "ogg" || extension == "w64" || extension == "wav")

  932.     {

  933. #ifdef WANT_AUDIOFILE

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

  935.         {

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

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

  938.             return true;

  939.         }

  940.         return false;

  941. #else

  942.         setLastError("This Carla build does not have Audio file support");

  943.         return false;

  944. #endif

  945.     }

  946. 

  947.     if (extension == "3g2" || extension == "3gp" || extension == "aac" || extension == "ac3" || extension == "amr" || extension == "ape" ||

  948.             extension == "mp2" || extension == "mp3" || extension == "mpc" || extension == "wma")

  949.     {

  950. #ifdef WANT_AUDIOFILE

  951. # ifdef HAVE_FFMPEG

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

  953.         {

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

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

  956.             return true;

  957.         }

  958.         return false;

  959. # else

  960.         setLastError("This Carla build has Audio file support, but not libav/ffmpeg");

  961.         return false;

  962. # endif

  963. #else

  964.         setLastError("This Carla build does not have Audio file support");

  965.         return false;

  966. #endif

  967.     }

  968. 

  969.     // -------------------------------------------------------------------

  970. 

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

  972.     {

  973. #ifdef WANT_MIDIFILE

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

  975.         {

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

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

  978.             return true;

  979.         }

  980.         return false;

  981. #else

  982.         setLastError("This Carla build does not have MIDI file support");

  983.         return false;

  984. #endif

  985.     }

  986. 

  987.     // -------------------------------------------------------------------

  988.     // ZynAddSubFX

  989. 

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

  991.     {

  992. #ifdef WANT_ZYNADDSUBFX

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

  994.         {

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

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

  997.             return true;

  998.         }

  999.         return false;

  1000. #else

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

  1002.         return false;

  1003. #endif

  1004.     }

  1005. 

  1006.     // -------------------------------------------------------------------

  1007. 

  1008.     setLastError("Unknown file extension");

  1009.     return false;

  1010. }

  1011. 

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

  1013. {

  1014.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename (err #2)");

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

  1016. 

  1017.     File file(filename);

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

  1019. 

  1020.     XmlDocument xml(file);

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

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

  1023. 

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

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

  1026. 

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

  1028.     {

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

  1030.         return false;

  1031.     }

  1032. 

  1033.     // completely load file

  1034.     xmlElement = xml.getDocumentElement(false);

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

  1036. 

  1037.     // handle plugins first

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

  1039.     {

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

  1041. 

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

  1043.         {

  1044.             StateSave stateSave;

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

  1046. 

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

  1048. 

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

  1050. 

  1051.             const void* extraStuff = nullptr;

  1052. 

  1053.             // check if using GIG, SF2 or SFZ 16outs

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

  1055. 

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

  1057. 

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

  1059.             {

  1060.                 if (ptype == PLUGIN_FILE_GIG || ptype == PLUGIN_FILE_SF2)

  1061.                     extraStuff = "true";

  1062.             }

  1063. 

  1064.             // TODO - proper find&load plugins

  1065. 

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

  1067.             {

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

  1069.                     plugin->loadStateSave(stateSave);

  1070.             }

  1071.             else

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

  1073.         }

  1074. 

  1075.         if (isPreset)

  1076.             return true;

  1077.     }

  1078. 

  1079. #ifndef BUILD_BRIDGE

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

  1081. 

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

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

  1084.     {

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

  1086.             return true;

  1087.     }

  1088. 

  1089.     // now handle connections

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

  1091.     {

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

  1093. 

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

  1095.         {

  1096.             CarlaString sourcePort, targetPort;

  1097. 

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

  1099.             {

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

  1101. 

  1102.                 sourcePort.clear();

  1103.                 targetPort.clear();

  1104. 

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

  1106.                     continue;

  1107. 

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

  1109.                 {

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

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

  1112. 

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

  1114.                         sourcePort = text.toRawUTF8();

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

  1116.                         targetPort = text.toRawUTF8();

  1117.                 }

  1118. 

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

  1120.                     restorePatchbayConnection(sourcePort, targetPort);

  1121.             }

  1122.             break;

  1123.         }

  1124.     }

  1125. #endif

  1126. 

  1127.     return true;

  1128. }

  1129. 

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

  1131. {

  1132.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename (err #3)");

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

  1134. 

  1135.     MemoryOutputStream out;

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

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

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

  1139. 

  1140.     bool firstPlugin = true;

  1141.     char strBuf[STR_MAX+1];

  1142. 

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

  1144.     {

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

  1146. 

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

  1148.         {

  1149.             if (! firstPlugin)

  1150.                 out << "\n";

  1151. 

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

  1153. 

  1154.             plugin->getRealName(strBuf);

  1155. 

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

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

  1158. 

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

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

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

  1162. 

  1163.             firstPlugin = false;

  1164.         }

  1165.     }

  1166. 

  1167. #ifndef BUILD_BRIDGE

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

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

  1170.     {

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

  1172.             return true;

  1173.     }

  1174. 

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

  1176.     {

  1177.         if (! firstPlugin)

  1178.             out << "\n";

  1179. 

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

  1181. 

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

  1183.         {

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

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

  1186. 

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

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

  1189. 

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

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

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

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

  1194. 

  1195.             delete[] connSource;

  1196.             delete[] connTarget;

  1197.         }

  1198. 

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

  1200.     }

  1201. #endif

  1202. 

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

  1204. 

  1205.     File file(filename);

  1206. 

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

  1208.         return true;

  1209. 

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

  1211.     return false;

  1212. }

  1213. 

  1214. // -----------------------------------------------------------------------

  1215. // Information (base)

  1216. 

  1217. uint CarlaEngine::getHints() const noexcept

  1218. {

  1219.     return pData->hints;

  1220. }

  1221. 

  1222. uint32_t CarlaEngine::getBufferSize() const noexcept

  1223. {

  1224.     return pData->bufferSize;

  1225. }

  1226. 

  1227. double CarlaEngine::getSampleRate() const noexcept

  1228. {

  1229.     return pData->sampleRate;

  1230. }

  1231. 

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

  1233. {

  1234.     return pData->name;

  1235. }

  1236. 

  1237. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1238. {

  1239.     return pData->options.processMode;

  1240. }

  1241. 

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

  1243. {

  1244.     return pData->options;

  1245. }

  1246. 

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

  1248. {

  1249.     return pData->timeInfo;

  1250. }

  1251. 

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

  1253. // Information (peaks)

  1254. 

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

  1256. {

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

  1258. 

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

  1260. }

  1261. 

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

  1263. {

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

  1265. 

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

  1267. }

  1268. 

  1269. // -----------------------------------------------------------------------

  1270. // Callback

  1271. 

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

  1273. {

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

  1275. 

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

  1277.     {

  1278.         try {

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

  1280.         } catch(...) {}

  1281.     }

  1282. }

  1283. 

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

  1285. {

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

  1287. 

  1288.     pData->callback    = func;

  1289.     pData->callbackPtr = ptr;

  1290. }

  1291. 

  1292. // -----------------------------------------------------------------------

  1293. // File Callback

  1294. 

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

  1296. {

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

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

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

  1300. 

  1301.     const char* ret = nullptr;

  1302. 

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

  1304.     {

  1305.         try {

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

  1307.         } catch(...) {}

  1308.     }

  1309. 

  1310.     return ret;

  1311. }

  1312. 

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

  1314. {

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

  1316. 

  1317.     pData->fileCallback    = func;

  1318.     pData->fileCallbackPtr = ptr;

  1319. }

  1320. 

  1321. #ifndef BUILD_BRIDGE

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

  1323. // Patchbay

  1324. 

  1325. bool CarlaEngine::patchbayConnect(const uint groupA, const uint portA, const uint groupB, const uint portB)

  1326. {

  1327.     CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY, false);

  1328.     CARLA_SAFE_ASSERT_RETURN(pData->audio.isReady, false);

  1329.     carla_debug("CarlaEngine::patchbayConnect(%u, %u, %u, %u)", groupA, portA, groupB, portB);

  1330. 

  1331.     if (pData->graph.isRack)

  1332.     {

  1333.         CARLA_SAFE_ASSERT_RETURN(pData->graph.rack != nullptr, nullptr);

  1334.         return pData->graph.rack->connect(this, groupA, portA, groupB, portB);

  1335.     }

  1336.     else

  1337.     {

  1338.         CARLA_SAFE_ASSERT_RETURN(pData->graph.patchbay != nullptr, nullptr);

  1339.         return pData->graph.patchbay->connect(this, groupA, portA, groupB, portB);

  1340.     }

  1341. }

  1342. 

  1343. bool CarlaEngine::patchbayDisconnect(const uint connectionId)

  1344. {

  1345.     CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY, false);

  1346.     CARLA_SAFE_ASSERT_RETURN(pData->audio.isReady, false);

  1347.     carla_debug("CarlaEngine::patchbayDisconnect(%u)", connectionId);

  1348. 

  1349.     if (pData->graph.isRack)

  1350.     {

  1351.         CARLA_SAFE_ASSERT_RETURN(pData->graph.rack != nullptr, nullptr);

  1352.         return pData->graph.rack->disconnect(this, connectionId);

  1353.     }

  1354.     else

  1355.     {

  1356.         CARLA_SAFE_ASSERT_RETURN(pData->graph.patchbay != nullptr, nullptr);

  1357.         return pData->graph.patchbay->disconnect(this, connectionId);

  1358.     }

  1359. }

  1360. 

  1361. bool CarlaEngine::patchbayRefresh()

  1362. {

  1363.     setLastError("Unsupported operation");

  1364.     return false;

  1365. }

  1366. #endif

  1367. 

  1368. // -----------------------------------------------------------------------

  1369. // Transport

  1370. 

  1371. void CarlaEngine::transportPlay() noexcept

  1372. {

  1373.     pData->time.playing = true;

  1374. }

  1375. 

  1376. void CarlaEngine::transportPause() noexcept

  1377. {

  1378.     pData->time.playing = false;

  1379. }

  1380. 

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

  1382. {

  1383.     pData->time.frame = frame;

  1384. }

  1385. 

  1386. // -----------------------------------------------------------------------

  1387. // Error handling

  1388. 

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

  1390. {

  1391.     return pData->lastError;

  1392. }

  1393. 

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

  1395. {

  1396.     pData->lastError = error;

  1397. }

  1398. 

  1399. void CarlaEngine::setAboutToClose() noexcept

  1400. {

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

  1402. 

  1403.     pData->aboutToClose = true;

  1404. }

  1405. 

  1406. // -----------------------------------------------------------------------

  1407. // Global options

  1408. 

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

  1410. {

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

  1412. 

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

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

  1415. 

  1416.     switch (option)

  1417.     {

  1418.     case ENGINE_OPTION_DEBUG:

  1419.     case ENGINE_OPTION_NSM_INIT:

  1420.         break;

  1421. 

  1422.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1425.         break;

  1426. 

  1427.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1430.         break;

  1431. 

  1432.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1435.         break;

  1436. 

  1437.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1440.         break;

  1441. 

  1442.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1445.         break;

  1446. 

  1447.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1450.         break;

  1451. 

  1452.     case ENGINE_OPTION_MAX_PARAMETERS:

  1453.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1455.         break;

  1456. 

  1457.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1458.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1460.         break;

  1461. 

  1462.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1465.         break;

  1466. 

  1467.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1468.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1470.         break;

  1471. 

  1472.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1473.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1475.         break;

  1476. 

  1477.     case ENGINE_OPTION_AUDIO_DEVICE:

  1478.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1479. 

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

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

  1482. 

  1483.         pData->options.audioDevice = carla_strdup(valueStr);

  1484.         break;

  1485. 

  1486.     case ENGINE_OPTION_PATH_BINARIES:

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

  1488. 

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

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

  1491. 

  1492.         pData->options.binaryDir = carla_strdup(valueStr);

  1493.         break;

  1494. 

  1495.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1497. 

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

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

  1500. 

  1501.         pData->options.resourceDir = carla_strdup(valueStr);

  1502.         break;

  1503. 

  1504.     case ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1507.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1509.         break;

  1510.     }

  1511. }

  1512. 

  1513. // -----------------------------------------------------------------------

  1514. // OSC Stuff

  1515. 

  1516. #ifdef BUILD_BRIDGE

  1517. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1518. {

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

  1520. }

  1521. #else

  1522. bool CarlaEngine::isOscControlRegistered() const noexcept

  1523. {

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

  1525. }

  1526. #endif

  1527. 

  1528. void CarlaEngine::idleOsc() const noexcept

  1529. {

  1530.     pData->osc.idle();

  1531. }

  1532. 

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

  1534. {

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

  1536. }

  1537. 

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

  1539. {

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

  1541. }

  1542. 

  1543. #ifdef BUILD_BRIDGE

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

  1545. {

  1546.     pData->oscData = oscData;

  1547. }

  1548. #endif

  1549. 

  1550. // -----------------------------------------------------------------------

  1551. // Helper functions

  1552. 

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

  1554. {

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

  1556. }

  1557. 

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

  1559. {

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

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

  1562. 

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

  1564. }

  1565. 

  1566. // -----------------------------------------------------------------------

  1567. // Internal stuff

  1568. 

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

  1570. {

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

  1572. 

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

  1574.     {

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

  1576. 

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

  1578.             plugin->bufferSizeChanged(newBufferSize);

  1579.     }

  1580. 

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

  1582. }

  1583. 

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

  1585. {

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

  1587. 

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

  1589.     {

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

  1591. 

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

  1593.             plugin->sampleRateChanged(newSampleRate);

  1594.     }

  1595. 

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

  1597. }

  1598. 

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

  1600. {

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

  1602. 

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

  1604.     {

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

  1606. 

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

  1608.             plugin->offlineModeChanged(isOfflineNow);

  1609.     }

  1610. }

  1611. 

  1612. void CarlaEngine::runPendingRtEvents() noexcept

  1613. {

  1614.     pData->doNextPluginAction(true);

  1615. 

  1616.     if (pData->time.playing)

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

  1618. 

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

  1620.     {

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

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

  1623.     }

  1624. }

  1625. 

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

  1627. {

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

  1629. 

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

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

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

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

  1634. }

  1635. 

  1636. #ifndef BUILD_BRIDGE

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

  1638. // Patchbay stuff

  1639. 

  1640. const char* const* CarlaEngine::getPatchbayConnections() const

  1641. {

  1642.     carla_debug("CarlaEngine::getPatchbayConnections()");

  1643. 

  1644.     if (pData->graph.isRack)

  1645.     {

  1646.         CARLA_SAFE_ASSERT_RETURN(pData->graph.rack != nullptr, nullptr);

  1647.         return pData->graph.rack->getConnections();

  1648.     }

  1649.     else

  1650.     {

  1651.         CARLA_SAFE_ASSERT_RETURN(pData->graph.patchbay != nullptr, nullptr);

  1652.         return pData->graph.patchbay->getConnections();

  1653.     }

  1654. }

  1655. 

  1656. void CarlaEngine::restorePatchbayConnection(const char* const connSource, const char* const connTarget)

  1657. {

  1658.     CARLA_SAFE_ASSERT_RETURN(connSource != nullptr && connSource[0] != '\0',);

  1659.     CARLA_SAFE_ASSERT_RETURN(connTarget != nullptr && connTarget[0] != '\0',);

  1660.     carla_debug("CarlaEngine::restorePatchbayConnection(\"%s\", \"%s\")", connSource, connTarget);

  1661. 

  1662.     uint groupA, portA;

  1663.     uint groupB, portB;

  1664. 

  1665.     if (pData->graph.isRack)

  1666.     {

  1667.         CARLA_SAFE_ASSERT_RETURN(pData->graph.rack != nullptr,);

  1668.         if (! pData->graph.rack->getPortIdFromFullName(connSource, groupA, portA))

  1669.             return;

  1670.         if (! pData->graph.rack->getPortIdFromFullName(connTarget, groupB, portB))

  1671.             return;

  1672.     }

  1673.     else

  1674.     {

  1675.         CARLA_SAFE_ASSERT_RETURN(pData->graph.patchbay != nullptr,);

  1676.         if (! pData->graph.patchbay->getPortIdFromFullName(connSource, groupA, portA))

  1677.             return;

  1678.         if (! pData->graph.patchbay->getPortIdFromFullName(connTarget, groupB, portB))

  1679.             return;

  1680.     }

  1681. 

  1682.     patchbayConnect(groupA, portA, groupB, portB);

  1683. }

  1684. #endif

  1685. 

  1686. // -----------------------------------------------------------------------

  1687. // Bridge/Controller OSC stuff

  1688. 

  1689. #ifdef BUILD_BRIDGE

  1690. void CarlaEngine::oscSend_bridge_plugin_info1(const PluginCategory category, const uint hints, const int64_t uniqueId) const noexcept

  1691. {

  1692.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1693.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1694.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1695.     carla_debug("CarlaEngine::oscSend_bridge_plugin_info1(%i:%s, %X, " P_INT64 ")", category, PluginCategory2Str(category), hints, uniqueId);

  1696. 

  1697.     char targetPath[std::strlen(pData->oscData->path)+21];

  1698.     std::strcpy(targetPath, pData->oscData->path);

  1699.     std::strcat(targetPath, "/bridge_plugin_info1");

  1700.     try_lo_send(pData->oscData->target, targetPath, "iih", static_cast<int32_t>(category), static_cast<int32_t>(hints), uniqueId);

  1701. }

  1702. 

  1703. void CarlaEngine::oscSend_bridge_plugin_info2(const char* const realName, const char* const label, const char* const maker, const char* const copyright) const noexcept

  1704. {

  1705.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1706.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1707.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1708.     CARLA_SAFE_ASSERT_RETURN(realName != nullptr && realName[0] != '\0',);

  1709.     CARLA_SAFE_ASSERT_RETURN(label != nullptr && label[0] != '\0',);

  1710.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  1711.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

  1712.     carla_debug("CarlaEngine::oscSend_bridge_plugin_info2(\"%s\", \"%s\", \"%s\", \"%s\")", realName, label, maker, copyright);

  1713. 

  1714.     char targetPath[std::strlen(pData->oscData->path)+21];

  1715.     std::strcpy(targetPath, pData->oscData->path);

  1716.     std::strcat(targetPath, "/bridge_plugin_info2");

  1717.     try_lo_send(pData->oscData->target, targetPath, "ssss", realName, label, maker, copyright);

  1718. }

  1719. 

  1720. void CarlaEngine::oscSend_bridge_audio_count(const uint32_t ins, const uint32_t outs) const noexcept

  1721. {

  1722.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1723.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1724.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1725.     carla_debug("CarlaEngine::oscSend_bridge_audio_count(%i, %i)", ins, outs);

  1726. 

  1727.     char targetPath[std::strlen(pData->oscData->path)+20];

  1728.     std::strcpy(targetPath, pData->oscData->path);

  1729.     std::strcat(targetPath, "/bridge_audio_count");

  1730.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  1731. }

  1732. 

  1733. void CarlaEngine::oscSend_bridge_midi_count(const uint32_t ins, const uint32_t outs) const noexcept

  1734. {

  1735.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1736.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1737.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1738.     carla_debug("CarlaEngine::oscSend_bridge_midi_count(%i, %i)", ins, outs);

  1739. 

  1740.     char targetPath[std::strlen(pData->oscData->path)+19];

  1741.     std::strcpy(targetPath, pData->oscData->path);

  1742.     std::strcat(targetPath, "/bridge_midi_count");

  1743.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  1744. }

  1745. 

  1746. void CarlaEngine::oscSend_bridge_parameter_count(const uint32_t ins, const uint32_t outs) const noexcept

  1747. {

  1748.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1749.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1750.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1751.     carla_debug("CarlaEngine::oscSend_bridge_parameter_count(%i, %i)", ins, outs);

  1752. 

  1753.     char targetPath[std::strlen(pData->oscData->path)+24];

  1754.     std::strcpy(targetPath, pData->oscData->path);

  1755.     std::strcat(targetPath, "/bridge_parameter_count");

  1756.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  1757. }

  1758. 

  1759. void CarlaEngine::oscSend_bridge_program_count(const uint32_t count) const noexcept

  1760. {

  1761.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1762.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1763.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1764.     carla_debug("CarlaEngine::oscSend_bridge_program_count(%i)", count);

  1765. 

  1766.     char targetPath[std::strlen(pData->oscData->path)+23];

  1767.     std::strcpy(targetPath, pData->oscData->path);

  1768.     std::strcat(targetPath, "/bridge_program_count");

  1769.     try_lo_send(pData->oscData->target, targetPath, "i", static_cast<int32_t>(count));

  1770. }

  1771. 

  1772. void CarlaEngine::oscSend_bridge_midi_program_count(const uint32_t count) const noexcept

  1773. {

  1774.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1775.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1776.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1777.     carla_debug("CarlaEngine::oscSend_bridge_midi_program_count(%i)", count);

  1778. 

  1779.     char targetPath[std::strlen(pData->oscData->path)+27];

  1780.     std::strcpy(targetPath, pData->oscData->path);

  1781.     std::strcat(targetPath, "/bridge_midi_program_count");

  1782.     try_lo_send(pData->oscData->target, targetPath, "i", static_cast<int32_t>(count));

  1783. }

  1784. 

  1785. void CarlaEngine::oscSend_bridge_parameter_data(const uint32_t index, const int32_t rindex, const ParameterType type, const uint hints, const char* const name, const char* const unit) const noexcept

  1786. {

  1787.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1788.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1789.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1790.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  1791.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

  1792.     carla_debug("CarlaEngine::oscSend_bridge_parameter_data(%i, %i, %i:%s, %X, \"%s\", \"%s\")", index, rindex, type, ParameterType2Str(type), hints, name, unit);

  1793. 

  1794.     char targetPath[std::strlen(pData->oscData->path)+24];

  1795.     std::strcpy(targetPath, pData->oscData->path);

  1796.     std::strcat(targetPath, "/bridge_parameter_data");

  1797.     try_lo_send(pData->oscData->target, targetPath, "iiiiss", static_cast<int32_t>(index), static_cast<int32_t>(rindex), static_cast<int32_t>(type), static_cast<int32_t>(hints), name, unit);

  1798. }

  1799. 

  1800. void CarlaEngine::oscSend_bridge_parameter_ranges1(const uint32_t index, const float def, const float min, const float max) const noexcept

  1801. {

  1802.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1803.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1804.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1805.     carla_debug("CarlaEngine::oscSend_bridge_parameter_ranges(%i, %f, %f, %f)", index, def, min, max);

  1806. 

  1807.     char targetPath[std::strlen(pData->oscData->path)+26];

  1808.     std::strcpy(targetPath, pData->oscData->path);

  1809.     std::strcat(targetPath, "/bridge_parameter_ranges1");

  1810.     try_lo_send(pData->oscData->target, targetPath, "ifff", static_cast<int32_t>(index), def, min, max);

  1811. }

  1812. 

  1813. void CarlaEngine::oscSend_bridge_parameter_ranges2(const uint32_t index, const float step, const float stepSmall, const float stepLarge) const noexcept

  1814. {

  1815.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1816.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1817.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1818.     carla_debug("CarlaEngine::oscSend_bridge_parameter_ranges(%i, %f, %f, %f)", index, step, stepSmall, stepLarge);

  1819. 

  1820.     char targetPath[std::strlen(pData->oscData->path)+26];

  1821.     std::strcpy(targetPath, pData->oscData->path);

  1822.     std::strcat(targetPath, "/bridge_parameter_ranges2");

  1823.     try_lo_send(pData->oscData->target, targetPath, "ifff", static_cast<int32_t>(index), step, stepSmall, stepLarge);

  1824. }

  1825. 

  1826. void CarlaEngine::oscSend_bridge_parameter_midi_cc(const uint32_t index, const int16_t cc) const noexcept

  1827. {

  1828.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1829.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1830.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1831.     carla_debug("CarlaEngine::oscSend_bridge_parameter_midi_cc(%i, %i)", index, cc);

  1832. 

  1833.     char targetPath[std::strlen(pData->oscData->path)+26];

  1834.     std::strcpy(targetPath, pData->oscData->path);

  1835.     std::strcat(targetPath, "/bridge_parameter_midi_cc");

  1836.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(index), static_cast<int32_t>(cc));

  1837. }

  1838. 

  1839. void CarlaEngine::oscSend_bridge_parameter_midi_channel(const uint32_t index, const uint8_t channel) const noexcept

  1840. {

  1841.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1842.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1843.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1844.     carla_debug("CarlaEngine::oscSend_bridge_parameter_midi_channel(%i, %i)", index, channel);

  1845. 

  1846.     char targetPath[std::strlen(pData->oscData->path)+31];

  1847.     std::strcpy(targetPath, pData->oscData->path);

  1848.     std::strcat(targetPath, "/bridge_parameter_midi_channel");

  1849.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(index), static_cast<int32_t>(channel));

  1850. }

  1851. 

  1852. void CarlaEngine::oscSend_bridge_parameter_value(const uint32_t index, const float value) const noexcept

  1853. {

  1854.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1855.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1856.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1857.     carla_debug("CarlaEngine::oscSend_bridge_parameter_value(%i, %f)", index, value);

  1858. 

  1859.     char targetPath[std::strlen(pData->oscData->path)+24];

  1860.     std::strcpy(targetPath, pData->oscData->path);

  1861.     std::strcat(targetPath, "/bridge_parameter_value");

  1862.     try_lo_send(pData->oscData->target, targetPath, "if", static_cast<int32_t>(index), value);

  1863. }

  1864. 

  1865. void CarlaEngine::oscSend_bridge_default_value(const uint32_t index, const float value) const noexcept

  1866. {

  1867.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1868.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1869.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1870.     carla_debug("CarlaEngine::oscSend_bridge_default_value(%i, %f)", index, value);

  1871. 

  1872.     char targetPath[std::strlen(pData->oscData->path)+22];

  1873.     std::strcpy(targetPath, pData->oscData->path);

  1874.     std::strcat(targetPath, "/bridge_default_value");

  1875.     try_lo_send(pData->oscData->target, targetPath, "if", static_cast<int32_t>(index), value);

  1876. }

  1877. 

  1878. void CarlaEngine::oscSend_bridge_current_program(const int32_t index) const noexcept

  1879. {

  1880.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1881.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1882.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1883.     carla_debug("CarlaEngine::oscSend_bridge_current_program(%i)", index);

  1884. 

  1885.     char targetPath[std::strlen(pData->oscData->path)+24];

  1886.     std::strcpy(targetPath, pData->oscData->path);

  1887.     std::strcat(targetPath, "/bridge_current_program");

  1888.     try_lo_send(pData->oscData->target, targetPath, "i", index);

  1889. }

  1890. 

  1891. void CarlaEngine::oscSend_bridge_current_midi_program(const int32_t index) const noexcept

  1892. {

  1893.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1894.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1895.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1896.     carla_debug("CarlaEngine::oscSend_bridge_current_midi_program(%i)", index);

  1897. 

  1898.     char targetPath[std::strlen(pData->oscData->path)+30];

  1899.     std::strcpy(targetPath, pData->oscData->path);

  1900.     std::strcat(targetPath, "/bridge_current_midi_program");

  1901.     try_lo_send(pData->oscData->target, targetPath, "i", index);

  1902. }

  1903. 

  1904. void CarlaEngine::oscSend_bridge_program_name(const uint32_t index, const char* const name) const noexcept

  1905. {

  1906.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1907.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1908.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1909.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  1910.     carla_debug("CarlaEngine::oscSend_bridge_program_name(%i, \"%s\")", index, name);

  1911. 

  1912.     char targetPath[std::strlen(pData->oscData->path)+21];

  1913.     std::strcpy(targetPath, pData->oscData->path);

  1914.     std::strcat(targetPath, "/bridge_program_name");

  1915.     try_lo_send(pData->oscData->target, targetPath, "is", static_cast<int32_t>(index), name);

  1916. }

  1917. 

  1918. void CarlaEngine::oscSend_bridge_midi_program_data(const uint32_t index, const uint32_t bank, const uint32_t program, const char* const name) const noexcept

  1919. {

  1920.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1921.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1922.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1923.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  1924.     carla_debug("CarlaEngine::oscSend_bridge_midi_program_data(%i, %i, %i, \"%s\")", index, bank, program, name);

  1925. 

  1926.     char targetPath[std::strlen(pData->oscData->path)+26];

  1927.     std::strcpy(targetPath, pData->oscData->path);

  1928.     std::strcat(targetPath, "/bridge_midi_program_data");

  1929.     try_lo_send(pData->oscData->target, targetPath, "iiis", static_cast<int32_t>(index), static_cast<int32_t>(bank), static_cast<int32_t>(program), name);

  1930. }

  1931. 

  1932. void CarlaEngine::oscSend_bridge_configure(const char* const key, const char* const value) const noexcept

  1933. {

  1934.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1935.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1936.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

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

  1938.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1939.     carla_debug("CarlaEngine::oscSend_bridge_configure(\"%s\", \"%s\")", key, value);

  1940. 

  1941.     char targetPath[std::strlen(pData->oscData->path)+18];

  1942.     std::strcpy(targetPath, pData->oscData->path);

  1943.     std::strcat(targetPath, "/bridge_configure");

  1944.     try_lo_send(pData->oscData->target, targetPath, "ss", key, value);

  1945. }

  1946. 

  1947. void CarlaEngine::oscSend_bridge_set_custom_data(const char* const type, const char* const key, const char* const value) const noexcept

  1948. {

  1949.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1950.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1951.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

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

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

  1954.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1955.     carla_debug("CarlaEngine::oscSend_bridge_set_custom_data(\"%s\", \"%s\", \"%s\")", type, key, value);

  1956. 

  1957.     char targetPath[std::strlen(pData->oscData->path)+24];

  1958.     std::strcpy(targetPath, pData->oscData->path);

  1959.     std::strcat(targetPath, "/bridge_set_custom_data");

  1960.     try_lo_send(pData->oscData->target, targetPath, "sss", type, key, value);

  1961. }

  1962. 

  1963. void CarlaEngine::oscSend_bridge_set_chunk_data(const char* const chunkFile) const noexcept

  1964. {

  1965.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1966.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1967.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1968.     CARLA_SAFE_ASSERT_RETURN(chunkFile != nullptr && chunkFile[0] != '\0',);

  1969.     carla_debug("CarlaEngine::oscSend_bridge_set_chunk_data(\"%s\")", chunkFile);

  1970. 

  1971.     char targetPath[std::strlen(pData->oscData->path)+23];

  1972.     std::strcpy(targetPath, pData->oscData->path);

  1973.     std::strcat(targetPath, "/bridge_set_chunk_data");

  1974.     try_lo_send(pData->oscData->target, targetPath, "s", chunkFile);

  1975. }

  1976. 

  1977. void CarlaEngine::oscSend_bridge_pong() const noexcept

  1978. {

  1979.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1980.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1981.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1982.     //carla_debug("CarlaEngine::oscSend_pong()");

  1983. 

  1984.     char targetPath[std::strlen(pData->oscData->path)+13];

  1985.     std::strcpy(targetPath, pData->oscData->path);

  1986.     std::strcat(targetPath, "/bridge_pong");

  1987.     try_lo_send(pData->oscData->target, targetPath, "");

  1988. }

  1989. #else

  1990. void CarlaEngine::oscSend_control_add_plugin_start(const uint pluginId, const char* const pluginName) const noexcept

  1991. {

  1992.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1993.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  1994.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  1995.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  1996.     CARLA_SAFE_ASSERT_RETURN(pluginName != nullptr && pluginName[0] != '\0',);

  1997.     carla_debug("CarlaEngine::oscSend_control_add_plugin_start(%i, \"%s\")", pluginId, pluginName);

  1998. 

  1999.     char targetPath[std::strlen(pData->oscData->path)+18];

  2000.     std::strcpy(targetPath, pData->oscData->path);

  2001.     std::strcat(targetPath, "/add_plugin_start");

  2002.     try_lo_send(pData->oscData->target, targetPath, "is", static_cast<int32_t>(pluginId), pluginName);

  2003. }

  2004. 

  2005. void CarlaEngine::oscSend_control_add_plugin_end(const uint pluginId) const noexcept

  2006. {

  2007.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2008.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2009.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2010.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2011.     carla_debug("CarlaEngine::oscSend_control_add_plugin_end(%i)", pluginId);

  2012. 

  2013.     char targetPath[std::strlen(pData->oscData->path)+16];

  2014.     std::strcpy(targetPath, pData->oscData->path);

  2015.     std::strcat(targetPath, "/add_plugin_end");

  2016.     try_lo_send(pData->oscData->target, targetPath, "i", static_cast<int32_t>(pluginId));

  2017. }

  2018. 

  2019. void CarlaEngine::oscSend_control_remove_plugin(const uint pluginId) const noexcept

  2020. {

  2021.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2022.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2023.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2024.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2025.     carla_debug("CarlaEngine::oscSend_control_remove_plugin(%i)", pluginId);

  2026. 

  2027.     char targetPath[std::strlen(pData->oscData->path)+15];

  2028.     std::strcpy(targetPath, pData->oscData->path);

  2029.     std::strcat(targetPath, "/remove_plugin");

  2030.     try_lo_send(pData->oscData->target, targetPath, "i", static_cast<int32_t>(pluginId));

  2031. }

  2032. 

  2033. void CarlaEngine::oscSend_control_set_plugin_info1(const uint pluginId, const PluginType type, const PluginCategory category, const uint hints, const int64_t uniqueId) const noexcept

  2034. {

  2035.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2036.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2037.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2038.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2039.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

  2040.     carla_debug("CarlaEngine::oscSend_control_set_plugin_data(%i, %i:%s, %i:%s, %X, " P_INT64 ")", pluginId, type, PluginType2Str(type), category, PluginCategory2Str(category), hints, uniqueId);

  2041. 

  2042.     char targetPath[std::strlen(pData->oscData->path)+18];

  2043.     std::strcpy(targetPath, pData->oscData->path);

  2044.     std::strcat(targetPath, "/set_plugin_info1");

  2045.     try_lo_send(pData->oscData->target, targetPath, "iiiih", static_cast<int32_t>(pluginId), static_cast<int32_t>(type), static_cast<int32_t>(category), static_cast<int32_t>(hints), static_cast<int64_t>(uniqueId));

  2046. }

  2047. 

  2048. void CarlaEngine::oscSend_control_set_plugin_info2(const uint pluginId, const char* const realName, const char* const label, const char* const maker, const char* const copyright) const noexcept

  2049. {

  2050.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2051.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2052.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2053.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2054.     CARLA_SAFE_ASSERT_RETURN(realName != nullptr && realName[0] != '\0',);

  2055.     CARLA_SAFE_ASSERT_RETURN(label != nullptr && label[0] != '\0',);

  2056.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  2057.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

  2058.     carla_debug("CarlaEngine::oscSend_control_set_plugin_data(%i, \"%s\", \"%s\", \"%s\", \"%s\")", pluginId, realName, label, maker, copyright);

  2059. 

  2060.     char targetPath[std::strlen(pData->oscData->path)+18];

  2061.     std::strcpy(targetPath, pData->oscData->path);

  2062.     std::strcat(targetPath, "/set_plugin_info2");

  2063.     try_lo_send(pData->oscData->target, targetPath, "issss", static_cast<int32_t>(pluginId), realName, label, maker, copyright);

  2064. }

  2065. 

  2066. void CarlaEngine::oscSend_control_set_audio_count(const uint pluginId, const uint32_t ins, const uint32_t outs) const noexcept

  2067. {

  2068.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2069.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2070.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2071.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2072.     carla_debug("CarlaEngine::oscSend_control_set_audio_count(%i, %i, %i)", pluginId, ins, outs);

  2073. 

  2074.     char targetPath[std::strlen(pData->oscData->path)+18];

  2075.     std::strcpy(targetPath, pData->oscData->path);

  2076.     std::strcat(targetPath, "/set_audio_count");

  2077.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  2078. }

  2079. 

  2080. void CarlaEngine::oscSend_control_set_midi_count(const uint pluginId, const uint32_t ins, const uint32_t outs) const noexcept

  2081. {

  2082.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2083.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2084.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2085.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2086.     carla_debug("CarlaEngine::oscSend_control_set_midi_count(%i, %i, %i)", pluginId, ins, outs);

  2087. 

  2088.     char targetPath[std::strlen(pData->oscData->path)+18];

  2089.     std::strcpy(targetPath, pData->oscData->path);

  2090.     std::strcat(targetPath, "/set_midi_count");

  2091.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  2092. }

  2093. 

  2094. void CarlaEngine::oscSend_control_set_parameter_count(const uint pluginId, const uint32_t ins, const uint32_t outs) const noexcept

  2095. {

  2096.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2097.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2098.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2099.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2100.     carla_debug("CarlaEngine::oscSend_control_set_parameter_count(%i, %i, %i)", pluginId, ins, outs);

  2101. 

  2102.     char targetPath[std::strlen(pData->oscData->path)+18];

  2103.     std::strcpy(targetPath, pData->oscData->path);

  2104.     std::strcat(targetPath, "/set_parameter_count");

  2105.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  2106. }

  2107. 

  2108. void CarlaEngine::oscSend_control_set_program_count(const uint pluginId, const uint32_t count) const noexcept

  2109. {

  2110.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2111.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2112.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2113.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2114.     carla_debug("CarlaEngine::oscSend_control_set_program_count(%i, %i)", pluginId, count);

  2115. 

  2116.     char targetPath[std::strlen(pData->oscData->path)+19];

  2117.     std::strcpy(targetPath, pData->oscData->path);

  2118.     std::strcat(targetPath, "/set_program_count");

  2119.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), static_cast<int32_t>(count));

  2120. }

  2121. 

  2122. void CarlaEngine::oscSend_control_set_midi_program_count(const uint pluginId, const uint32_t count) const noexcept

  2123. {

  2124.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2125.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2126.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2127.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2128.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_count(%i, %i)", pluginId, count);

  2129. 

  2130.     char targetPath[std::strlen(pData->oscData->path)+24];

  2131.     std::strcpy(targetPath, pData->oscData->path);

  2132.     std::strcat(targetPath, "/set_midi_program_count");

  2133.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), static_cast<int32_t>(count));

  2134. }

  2135. 

  2136. void CarlaEngine::oscSend_control_set_parameter_data(const uint pluginId, const uint32_t index, const ParameterType type, const uint hints, const char* const name, const char* const unit) const noexcept

  2137. {

  2138.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2139.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2140.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2141.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

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

  2143.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

  2144.     carla_debug("CarlaEngine::oscSend_control_set_parameter_data(%i, %i, %i:%s, %X, \"%s\", \"%s\")", pluginId, index, type, ParameterType2Str(type), hints, name, unit);

  2145. 

  2146.     char targetPath[std::strlen(pData->oscData->path)+20];

  2147.     std::strcpy(targetPath, pData->oscData->path);

  2148.     std::strcat(targetPath, "/set_parameter_data");

  2149.     try_lo_send(pData->oscData->target, targetPath, "iiiiss", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(type), static_cast<int32_t>(hints), name, unit);

  2150. }

  2151. 

  2152. void CarlaEngine::oscSend_control_set_parameter_ranges1(const uint pluginId, const uint32_t index, const float def, const float min, const float max) const noexcept

  2153. {

  2154.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2155.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2156.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2157.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2158.     CARLA_SAFE_ASSERT_RETURN(def <= min && def >= max,);

  2159.     CARLA_SAFE_ASSERT_RETURN(min < max,);

  2160.     carla_debug("CarlaEngine::oscSend_control_set_parameter_ranges1(%i, %i, %f, %f, %f)", pluginId, index, def, min, max, def);

  2161. 

  2162.     char targetPath[std::strlen(pData->oscData->path)+23];

  2163.     std::strcpy(targetPath, pData->oscData->path);

  2164.     std::strcat(targetPath, "/set_parameter_ranges1");

  2165.     try_lo_send(pData->oscData->target, targetPath, "iifff", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), def, min, max);

  2166. }

  2167. 

  2168. void CarlaEngine::oscSend_control_set_parameter_ranges2(const uint pluginId, const uint32_t index, const float step, const float stepSmall, const float stepLarge) const noexcept

  2169. {

  2170.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2171.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2172.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2173.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2174.     CARLA_SAFE_ASSERT_RETURN(step <= stepSmall && step >= stepLarge,);

  2175.     CARLA_SAFE_ASSERT_RETURN(stepSmall <= stepLarge,);

  2176.     carla_debug("CarlaEngine::oscSend_control_set_parameter_ranges2(%i, %i, %f, %f, %f)", pluginId, index, step, stepSmall, stepLarge);

  2177. 

  2178.     char targetPath[std::strlen(pData->oscData->path)+23];

  2179.     std::strcpy(targetPath, pData->oscData->path);

  2180.     std::strcat(targetPath, "/set_parameter_ranges");

  2181.     try_lo_send(pData->oscData->target, targetPath, "iifff", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), step, stepSmall, stepLarge);

  2182. }

  2183. 

  2184. void CarlaEngine::oscSend_control_set_parameter_midi_cc(const uint pluginId, const uint32_t index, const int16_t cc) const noexcept

  2185. {

  2186.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2187.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2188.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2189.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2190.     CARLA_SAFE_ASSERT_RETURN(cc <= 0x5F,);

  2191.     carla_debug("CarlaEngine::oscSend_control_set_parameter_midi_cc(%i, %i, %i)", pluginId, index, cc);

  2192. 

  2193.     char targetPath[std::strlen(pData->oscData->path)+23];

  2194.     std::strcpy(targetPath, pData->oscData->path);

  2195.     std::strcat(targetPath, "/set_parameter_midi_cc");

  2196.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(cc));

  2197. }

  2198. 

  2199. void CarlaEngine::oscSend_control_set_parameter_midi_channel(const uint pluginId, const uint32_t index, const uint8_t channel) const noexcept

  2200. {

  2201.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2202.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2203.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2204.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2205.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2206.     carla_debug("CarlaEngine::oscSend_control_set_parameter_midi_channel(%i, %i, %i)", pluginId, index, channel);

  2207. 

  2208.     char targetPath[std::strlen(pData->oscData->path)+28];

  2209.     std::strcpy(targetPath, pData->oscData->path);

  2210.     std::strcat(targetPath, "/set_parameter_midi_channel");

  2211.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(channel));

  2212. }

  2213. 

  2214. void CarlaEngine::oscSend_control_set_parameter_value(const uint pluginId, const int32_t index, const float value) const noexcept

  2215. {

  2216.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2217.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2218.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2219.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2220.     CARLA_SAFE_ASSERT_RETURN(index != PARAMETER_NULL,);

  2221.     carla_debug("CarlaEngine::oscSend_control_set_parameter_value(%i, %i:%s, %f)", pluginId, index, (index < 0) ? InternalParameterIndex2Str(static_cast<InternalParameterIndex>(index)) : "(none)", value);

  2222. 

  2223.     char targetPath[std::strlen(pData->oscData->path)+21];

  2224.     std::strcpy(targetPath, pData->oscData->path);

  2225.     std::strcat(targetPath, "/set_parameter_value");

  2226.     try_lo_send(pData->oscData->target, targetPath, "iif", static_cast<int32_t>(pluginId), index, value);

  2227. }

  2228. 

  2229. void CarlaEngine::oscSend_control_set_default_value(const uint pluginId, const uint32_t index, const float value) const noexcept

  2230. {

  2231.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2232.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2233.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2234.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2235.     carla_debug("CarlaEngine::oscSend_control_set_default_value(%i, %i, %f)", pluginId, index, value);

  2236. 

  2237.     char targetPath[std::strlen(pData->oscData->path)+19];

  2238.     std::strcpy(targetPath, pData->oscData->path);

  2239.     std::strcat(targetPath, "/set_default_value");

  2240.     try_lo_send(pData->oscData->target, targetPath, "iif", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), value);

  2241. }

  2242. 

  2243. void CarlaEngine::oscSend_control_set_current_program(const uint pluginId, const int32_t index) const noexcept

  2244. {

  2245.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2246.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2247.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2248.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2249.     carla_debug("CarlaEngine::oscSend_control_set_current_program(%i, %i)", pluginId, index);

  2250. 

  2251.     char targetPath[std::strlen(pData->oscData->path)+21];

  2252.     std::strcpy(targetPath, pData->oscData->path);

  2253.     std::strcat(targetPath, "/set_current_program");

  2254.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), index);

  2255. }

  2256. 

  2257. void CarlaEngine::oscSend_control_set_current_midi_program(const uint pluginId, const int32_t index) const noexcept

  2258. {

  2259.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2260.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2261.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2262.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2263.     carla_debug("CarlaEngine::oscSend_control_set_current_midi_program(%i, %i)", pluginId, index);

  2264. 

  2265.     char targetPath[std::strlen(pData->oscData->path)+26];

  2266.     std::strcpy(targetPath, pData->oscData->path);

  2267.     std::strcat(targetPath, "/set_current_midi_program");

  2268.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), index);

  2269. }

  2270. 

  2271. void CarlaEngine::oscSend_control_set_program_name(const uint pluginId, const uint32_t index, const char* const name) const noexcept

  2272. {

  2273.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2274.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2275.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2276.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2277.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2278.     carla_debug("CarlaEngine::oscSend_control_set_program_name(%i, %i, \"%s\")", pluginId, index, name);

  2279. 

  2280.     char targetPath[std::strlen(pData->oscData->path)+18];

  2281.     std::strcpy(targetPath, pData->oscData->path);

  2282.     std::strcat(targetPath, "/set_program_name");

  2283.     try_lo_send(pData->oscData->target, targetPath, "iis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), name);

  2284. }

  2285. 

  2286. void CarlaEngine::oscSend_control_set_midi_program_data(const uint pluginId, const uint32_t index, const uint32_t bank, const uint32_t program, const char* const name) const noexcept

  2287. {

  2288.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2289.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2290.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2291.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2292.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2293.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_data(%i, %i, %i, %i, \"%s\")", pluginId, index, bank, program, name);

  2294. 

  2295.     char targetPath[std::strlen(pData->oscData->path)+23];

  2296.     std::strcpy(targetPath, pData->oscData->path);

  2297.     std::strcat(targetPath, "/set_midi_program_data");

  2298.     try_lo_send(pData->oscData->target, targetPath, "iiiis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(bank), static_cast<int32_t>(program), name);

  2299. }

  2300. 

  2301. void CarlaEngine::oscSend_control_note_on(const uint pluginId, const uint8_t channel, const uint8_t note, const uint8_t velo) const noexcept

  2302. {

  2303.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2304.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2305.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2306.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2307.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2308.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2309.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2310.     carla_debug("CarlaEngine::oscSend_control_note_on(%i, %i, %i, %i)", pluginId, channel, note, velo);

  2311. 

  2312.     char targetPath[std::strlen(pData->oscData->path)+9];

  2313.     std::strcpy(targetPath, pData->oscData->path);

  2314.     std::strcat(targetPath, "/note_on");

  2315.     try_lo_send(pData->oscData->target, targetPath, "iiii", static_cast<int32_t>(pluginId), static_cast<int32_t>(channel), static_cast<int32_t>(note), static_cast<int32_t>(velo));

  2316. }

  2317. 

  2318. void CarlaEngine::oscSend_control_note_off(const uint pluginId, const uint8_t channel, const uint8_t note) const noexcept

  2319. {

  2320.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2321.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2322.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2323.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2324.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2325.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2326.     carla_debug("CarlaEngine::oscSend_control_note_off(%i, %i, %i)", pluginId, channel, note);

  2327. 

  2328.     char targetPath[std::strlen(pData->oscData->path)+10];

  2329.     std::strcpy(targetPath, pData->oscData->path);

  2330.     std::strcat(targetPath, "/note_off");

  2331.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(channel), static_cast<int32_t>(note));

  2332. }

  2333. 

  2334. void CarlaEngine::oscSend_control_set_peaks(const uint pluginId) const noexcept

  2335. {

  2336.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2337.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2338.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2339.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2340. 

  2341.     // TODO - try and see if we can get peaks[4] ref

  2342.     const EnginePluginData& epData(pData->plugins[pluginId]);

  2343. 

  2344.     char targetPath[std::strlen(pData->oscData->path)+11];

  2345.     std::strcpy(targetPath, pData->oscData->path);

  2346.     std::strcat(targetPath, "/set_peaks");

  2347.     try_lo_send(pData->oscData->target, targetPath, "iffff", static_cast<int32_t>(pluginId), epData.insPeak[0], epData.insPeak[1], epData.outsPeak[0], epData.outsPeak[1]);

  2348. }

  2349. 

  2350. void CarlaEngine::oscSend_control_exit() const noexcept

  2351. {

  2352.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2353.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2354.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2355.     carla_debug("CarlaEngine::oscSend_control_exit()");

  2356. 

  2357.     char targetPath[std::strlen(pData->oscData->path)+6];

  2358.     std::strcpy(targetPath, pData->oscData->path);

  2359.     std::strcat(targetPath, "/exit");

  2360.     try_lo_send(pData->oscData->target, targetPath, "");

  2361. }

  2362. #endif

  2363. 

  2364. // -----------------------------------------------------------------------

  2365. 

  2366. CARLA_BACKEND_END_NAMESPACE