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

2348 lines
90KB
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, "FluidSynth") == 0)

  474.             {

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

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

  477.             }

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

  479.             {

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

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

  482.             }

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

  484.             {

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

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

  487.             }

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

  489.             {

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

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

  492.             }

  493.             else

  494.             {

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

  496.             }

  497.             break;

  498. 

  499.         case PLUGIN_LADSPA:

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

  501.             break;

  502. 

  503.         case PLUGIN_DSSI:

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

  505.             break;

  506. 

  507.         case PLUGIN_LV2:

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

  509.             break;

  510. 

  511.         case PLUGIN_VST:

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

  513.             break;

  514. 

  515.         case PLUGIN_VST3:

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

  517.             break;

  518. 

  519.         case PLUGIN_AU:

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

  521.             break;

  522. 

  523.         case PLUGIN_GIG:

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

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

  526.             break;

  527. 

  528.         case PLUGIN_SF2:

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

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

  531.             break;

  532. 

  533.         case PLUGIN_SFZ:

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

  535.             break;

  536.         }

  537.     }

  538. 

  539.     if (plugin == nullptr)

  540.     {

  541. #ifndef BUILD_BRIDGE

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

  543. #endif

  544.         return false;

  545.     }

  546. 

  547.     plugin->registerToOscClient();

  548. 

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

  550.     pluginData.plugin      = plugin;

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

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

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

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

  555. 

  556. #ifndef BUILD_BRIDGE

  557.     if (oldPlugin != nullptr)

  558.     {

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

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

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

  562. 

  563.         delete oldPlugin;

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

  565. 

  566.         if (wasActive)

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

  568. 

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

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

  571. 

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

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

  574.     }

  575.     else

  576. #endif

  577.     {

  578.         ++pData->curPluginCount;

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

  580. 

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

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

  583.     }

  584. 

  585.     return true;

  586. }

  587. 

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

  589. {

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

  591. }

  592. 

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

  594. {

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

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

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

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

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

  600. 

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

  602. 

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

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

  605. 

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

  607. 

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

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

  610. 

  611. #ifndef BUILD_BRIDGE

  612.     if (isOscControlRegistered())

  613.         oscSend_control_remove_plugin(id);

  614. #endif

  615. 

  616.     delete plugin;

  617. 

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

  619.         pData->thread.startThread();

  620. 

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

  622.     return true;

  623. }

  624. 

  625. bool CarlaEngine::removeAllPlugins()

  626. {

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

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

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

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

  631. 

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

  633.         return true;

  634. 

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

  636. 

  637.     const bool lockWait(isRunning());

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

  639. 

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

  641. 

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

  643.     {

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

  645. 

  646.         if (pluginData.plugin != nullptr)

  647.         {

  648.             delete pluginData.plugin;

  649.             pluginData.plugin = nullptr;

  650.         }

  651. 

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

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

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

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

  656. 

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

  658.     }

  659. 

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

  661.         pData->thread.startThread();

  662. 

  663.     return true;

  664. }

  665. 

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

  667. {

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

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

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

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

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

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

  674. 

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

  676. 

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

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

  679. 

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

  681.     {

  682.         plugin->setName(name);

  683.         return name;

  684.     }

  685. 

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

  687.     return nullptr;

  688. }

  689. 

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

  691. {

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

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

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

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

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

  697. 

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

  699. 

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

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

  702. 

  703.     char label[STR_MAX+1];

  704.     carla_zeroChar(label, STR_MAX+1);

  705.     plugin->getLabel(label);

  706. 

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

  708. 

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

  710.         return false;

  711. 

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

  713. 

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

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

  716. 

  717.     return true;

  718. }

  719. 

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

  721. {

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

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

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

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

  726. 

  727.     // might use this to reset

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

  729.     {

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

  731.         return true;

  732.     }

  733. 

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

  735. 

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

  737. 

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

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

  740. 

  741.     pData->nextPluginId = id;

  742. 

  743.     return true;

  744. }

  745. 

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

  747. {

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

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

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

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

  752.     CARLA_SAFE_ASSERT_RETURN_ERR(idA < pData->curPluginCount, "Invalid plugin Id (err #5)");

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

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

  755. 

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

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

  758. 

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

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

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

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

  763. 

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

  765. 

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

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

  768. 

  769. #ifndef BUILD_BRIDGE // TODO

  770.     //if (isOscControlRegistered())

  771.     //    oscSend_control_switch_plugins(idA, idB);

  772. #endif

  773. 

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

  775.         pData->thread.startThread();

  776. 

  777.     return true;

  778. }

  779. 

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

  781. {

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

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

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

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

  786. 

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

  788. }

  789. 

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

  791. {

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

  793. }

  794. 

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

  796. {

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

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

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

  800. 

  801.     CarlaString sname;

  802.     sname = name;

  803. 

  804.     if (sname.isEmpty())

  805.     {

  806.         sname = "(No name)";

  807.         return sname.dup();

  808.     }

  809. 

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

  811. 

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

  813.         return sname.dup();

  814. 

  815.     sname.truncate(maxNameSize);

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

  817. 

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

  819.     {

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

  821. 

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

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

  824.         {

  825.             if (sname != pluginName)

  826.                 continue;

  827.         }

  828. 

  829.         // Check if string has already been modified

  830.         {

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

  832. 

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

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

  835.             {

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

  837. 

  838.                 if (number == 9)

  839.                 {

  840.                     // next number is 10, 2 digits

  841.                     sname.truncate(len-4);

  842.                     sname += " (10)";

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

  844.                 }

  845.                 else

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

  847. 

  848.                 continue;

  849.             }

  850. 

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

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

  853.             {

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

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

  856. 

  857.                 if (n2 == '9')

  858.                 {

  859.                     n2 = '0';

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

  861.                 }

  862.                 else

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

  864. 

  865.                 sname[len-2] = n2;

  866.                 sname[len-3] = n3;

  867. 

  868.                 continue;

  869.             }

  870.         }

  871. 

  872.         // Modify string if not

  873.         sname += " (2)";

  874.     }

  875. 

  876.     return sname.dup();

  877. }

  878. 

  879. // -----------------------------------------------------------------------

  880. // Project management

  881. 

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

  883. {

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

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

  886. 

  887.     File file(filename);

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

  889. 

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

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

  892.     extension.toLower();

  893. 

  894.     // -------------------------------------------------------------------

  895. 

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

  897.         return loadProject(filename);

  898. 

  899.     // -------------------------------------------------------------------

  900. 

  901.     if (extension == "gig")

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

  903. 

  904.     if (extension == "sf2")

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

  906. 

  907.     if (extension == "sfz")

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

  909. 

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

  911. 

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

  913.     {

  914. #ifdef WANT_AUDIOFILE

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

  916.         {

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

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

  919.             return true;

  920.         }

  921.         return false;

  922. #else

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

  924.         return false;

  925. #endif

  926.     }

  927. 

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

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

  930.     {

  931. #ifdef WANT_AUDIOFILE

  932. # ifdef HAVE_FFMPEG

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

  934.         {

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

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

  937.             return true;

  938.         }

  939.         return false;

  940. # else

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

  942.         return false;

  943. # endif

  944. #else

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

  946.         return false;

  947. #endif

  948.     }

  949. 

  950.     // -------------------------------------------------------------------

  951. 

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

  953.     {

  954. #ifdef WANT_MIDIFILE

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

  956.         {

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

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

  959.             return true;

  960.         }

  961.         return false;

  962. #else

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

  964.         return false;

  965. #endif

  966.     }

  967. 

  968.     // -------------------------------------------------------------------

  969.     // ZynAddSubFX

  970. 

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

  972.     {

  973. #ifdef WANT_ZYNADDSUBFX

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

  975.         {

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

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

  978.             return true;

  979.         }

  980.         return false;

  981. #else

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

  983.         return false;

  984. #endif

  985.     }

  986. 

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

  988. 

  989.     setLastError("Unknown file extension");

  990.     return false;

  991. }

  992. 

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

  994. {

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

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

  997. 

  998.     File file(filename);

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

  1000. 

  1001.     XmlDocument xml(file);

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

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

  1004. 

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

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

  1007. 

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

  1009.     {

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

  1011.         return false;

  1012.     }

  1013. 

  1014.     // completely load file

  1015.     xmlElement = xml.getDocumentElement(false);

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

  1017. 

  1018.     // handle plugins first

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

  1020.     {

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

  1022. 

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

  1024.         {

  1025.             StateSave stateSave;

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

  1027. 

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

  1029. 

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

  1031. 

  1032.             const void* extraStuff = nullptr;

  1033. 

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

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

  1036. 

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

  1038. 

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

  1040.             {

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

  1042.                     extraStuff = "true";

  1043.             }

  1044. 

  1045.             // TODO - proper find&load plugins

  1046. 

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

  1048.             {

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

  1050.                     plugin->loadStateSave(stateSave);

  1051.             }

  1052.             else

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

  1054.         }

  1055. 

  1056.         if (isPreset)

  1057.             return true;

  1058.     }

  1059. 

  1060. #ifndef BUILD_BRIDGE

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

  1062. 

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

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

  1065.     {

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

  1067.             return true;

  1068.     }

  1069. 

  1070.     // now handle connections

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

  1072.     {

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

  1074. 

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

  1076.         {

  1077.             CarlaString sourcePort, targetPort;

  1078. 

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

  1080.             {

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

  1082. 

  1083.                 sourcePort.clear();

  1084.                 targetPort.clear();

  1085. 

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

  1087.                     continue;

  1088. 

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

  1090.                 {

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

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

  1093. 

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

  1095.                         sourcePort = text.toRawUTF8();

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

  1097.                         targetPort = text.toRawUTF8();

  1098.                 }

  1099. 

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

  1101.                     restorePatchbayConnection(sourcePort, targetPort);

  1102.             }

  1103.             break;

  1104.         }

  1105.     }

  1106. #endif

  1107. 

  1108.     return true;

  1109. }

  1110. 

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

  1112. {

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

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

  1115. 

  1116.     MemoryOutputStream out;

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

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

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

  1120. 

  1121.     bool firstPlugin = true;

  1122.     char strBuf[STR_MAX+1];

  1123. 

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

  1125.     {

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

  1127. 

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

  1129.         {

  1130.             if (! firstPlugin)

  1131.                 out << "\n";

  1132. 

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

  1134. 

  1135.             plugin->getRealName(strBuf);

  1136. 

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

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

  1139. 

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

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

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

  1143. 

  1144.             firstPlugin = false;

  1145.         }

  1146.     }

  1147. 

  1148. #ifndef BUILD_BRIDGE

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

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

  1151.     {

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

  1153.             return true;

  1154.     }

  1155. 

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

  1157.     {

  1158.         if (! firstPlugin)

  1159.             out << "\n";

  1160. 

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

  1162. 

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

  1164.         {

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

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

  1167. 

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

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

  1170. 

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

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

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

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

  1175. 

  1176.             delete[] connSource;

  1177.             delete[] connTarget;

  1178.         }

  1179. 

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

  1181.     }

  1182. #endif

  1183. 

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

  1185. 

  1186.     File file(filename);

  1187. 

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

  1189.         return true;

  1190. 

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

  1192.     return false;

  1193. }

  1194. 

  1195. // -----------------------------------------------------------------------

  1196. // Information (base)

  1197. 

  1198. uint CarlaEngine::getHints() const noexcept

  1199. {

  1200.     return pData->hints;

  1201. }

  1202. 

  1203. uint32_t CarlaEngine::getBufferSize() const noexcept

  1204. {

  1205.     return pData->bufferSize;

  1206. }

  1207. 

  1208. double CarlaEngine::getSampleRate() const noexcept

  1209. {

  1210.     return pData->sampleRate;

  1211. }

  1212. 

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

  1214. {

  1215.     return pData->name;

  1216. }

  1217. 

  1218. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1219. {

  1220.     return pData->options.processMode;

  1221. }

  1222. 

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

  1224. {

  1225.     return pData->options;

  1226. }

  1227. 

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

  1229. {

  1230.     return pData->timeInfo;

  1231. }

  1232. 

  1233. // -----------------------------------------------------------------------

  1234. // Information (peaks)

  1235. 

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

  1237. {

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

  1239. 

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

  1241. }

  1242. 

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

  1244. {

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

  1246. 

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

  1248. }

  1249. 

  1250. // -----------------------------------------------------------------------

  1251. // Callback

  1252. 

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

  1254. {

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

  1256. 

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

  1258.     {

  1259.         try {

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

  1261.         } catch(...) {}

  1262.     }

  1263. }

  1264. 

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

  1266. {

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

  1268. 

  1269.     pData->callback    = func;

  1270.     pData->callbackPtr = ptr;

  1271. }

  1272. 

  1273. // -----------------------------------------------------------------------

  1274. // File Callback

  1275. 

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

  1277. {

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

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

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

  1281. 

  1282.     const char* ret = nullptr;

  1283. 

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

  1285.     {

  1286.         try {

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

  1288.         } catch(...) {}

  1289.     }

  1290. 

  1291.     return ret;

  1292. }

  1293. 

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

  1295. {

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

  1297. 

  1298.     pData->fileCallback    = func;

  1299.     pData->fileCallbackPtr = ptr;

  1300. }

  1301. 

  1302. #ifndef BUILD_BRIDGE

  1303. // -----------------------------------------------------------------------

  1304. // Patchbay

  1305. 

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

  1307. {

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

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

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

  1311. 

  1312.     if (pData->graph.isRack)

  1313.     {

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

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

  1316.     }

  1317.     else

  1318.     {

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

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

  1321.     }

  1322. }

  1323. 

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

  1325. {

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

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

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

  1329. 

  1330.     if (pData->graph.isRack)

  1331.     {

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

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

  1334.     }

  1335.     else

  1336.     {

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

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

  1339.     }

  1340. }

  1341. 

  1342. bool CarlaEngine::patchbayRefresh()

  1343. {

  1344.     setLastError("Unsupported operation");

  1345.     return false;

  1346. }

  1347. #endif

  1348. 

  1349. // -----------------------------------------------------------------------

  1350. // Transport

  1351. 

  1352. void CarlaEngine::transportPlay() noexcept

  1353. {

  1354.     pData->time.playing = true;

  1355. }

  1356. 

  1357. void CarlaEngine::transportPause() noexcept

  1358. {

  1359.     pData->time.playing = false;

  1360. }

  1361. 

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

  1363. {

  1364.     pData->time.frame = frame;

  1365. }

  1366. 

  1367. // -----------------------------------------------------------------------

  1368. // Error handling

  1369. 

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

  1371. {

  1372.     return pData->lastError;

  1373. }

  1374. 

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

  1376. {

  1377.     pData->lastError = error;

  1378. }

  1379. 

  1380. void CarlaEngine::setAboutToClose() noexcept

  1381. {

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

  1383. 

  1384.     pData->aboutToClose = true;

  1385. }

  1386. 

  1387. // -----------------------------------------------------------------------

  1388. // Global options

  1389. 

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

  1391. {

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

  1393. 

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

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

  1396. 

  1397.     switch (option)

  1398.     {

  1399.     case ENGINE_OPTION_DEBUG:

  1400.     case ENGINE_OPTION_NSM_INIT:

  1401.         break;

  1402. 

  1403.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1406.         break;

  1407. 

  1408.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1411.         break;

  1412. 

  1413.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1416.         break;

  1417. 

  1418.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1421.         break;

  1422. 

  1423.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1426.         break;

  1427. 

  1428.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1431.         break;

  1432. 

  1433.     case ENGINE_OPTION_MAX_PARAMETERS:

  1434.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1436.         break;

  1437. 

  1438.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1439.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1441.         break;

  1442. 

  1443.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1446.         break;

  1447. 

  1448.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1449.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1451.         break;

  1452. 

  1453.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1454.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1456.         break;

  1457. 

  1458.     case ENGINE_OPTION_AUDIO_DEVICE:

  1459.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1460. 

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

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

  1463. 

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

  1465.         break;

  1466. 

  1467.     case ENGINE_OPTION_PATH_BINARIES:

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

  1469. 

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

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

  1472. 

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

  1474.         break;

  1475. 

  1476.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1478. 

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

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

  1481. 

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

  1483.         break;

  1484. 

  1485.     case ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1488.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1490.         break;

  1491.     }

  1492. }

  1493. 

  1494. // -----------------------------------------------------------------------

  1495. // OSC Stuff

  1496. 

  1497. #ifdef BUILD_BRIDGE

  1498. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1499. {

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

  1501. }

  1502. #else

  1503. bool CarlaEngine::isOscControlRegistered() const noexcept

  1504. {

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

  1506. }

  1507. #endif

  1508. 

  1509. void CarlaEngine::idleOsc() const noexcept

  1510. {

  1511.     pData->osc.idle();

  1512. }

  1513. 

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

  1515. {

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

  1517. }

  1518. 

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

  1520. {

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

  1522. }

  1523. 

  1524. #ifdef BUILD_BRIDGE

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

  1526. {

  1527.     pData->oscData = oscData;

  1528. }

  1529. #endif

  1530. 

  1531. // -----------------------------------------------------------------------

  1532. // Helper functions

  1533. 

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

  1535. {

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

  1537. }

  1538. 

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

  1540. {

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

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

  1543. 

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

  1545. }

  1546. 

  1547. // -----------------------------------------------------------------------

  1548. // Internal stuff

  1549. 

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

  1551. {

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

  1553. 

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

  1555.     {

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

  1557. 

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

  1559.             plugin->bufferSizeChanged(newBufferSize);

  1560.     }

  1561. 

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

  1563. }

  1564. 

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

  1566. {

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

  1568. 

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

  1570.     {

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

  1572. 

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

  1574.             plugin->sampleRateChanged(newSampleRate);

  1575.     }

  1576. 

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

  1578. }

  1579. 

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

  1581. {

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

  1583. 

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

  1585.     {

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

  1587. 

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

  1589.             plugin->offlineModeChanged(isOfflineNow);

  1590.     }

  1591. }

  1592. 

  1593. void CarlaEngine::runPendingRtEvents() noexcept

  1594. {

  1595.     pData->doNextPluginAction(true);

  1596. 

  1597.     if (pData->time.playing)

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

  1599. 

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

  1601.     {

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

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

  1604.     }

  1605. }

  1606. 

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

  1608. {

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

  1610. 

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

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

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

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

  1615. }

  1616. 

  1617. #ifndef BUILD_BRIDGE

  1618. // -----------------------------------------------------------------------

  1619. // Patchbay stuff

  1620. 

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

  1622. {

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

  1624. 

  1625.     if (pData->graph.isRack)

  1626.     {

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

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

  1629.     }

  1630.     else

  1631.     {

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

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

  1634.     }

  1635. }

  1636. 

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

  1638. {

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

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

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

  1642. 

  1643.     uint groupA, portA;

  1644.     uint groupB, portB;

  1645. 

  1646.     if (pData->graph.isRack)

  1647.     {

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

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

  1650.             return;

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

  1652.             return;

  1653.     }

  1654.     else

  1655.     {

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

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

  1658.             return;

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

  1660.             return;

  1661.     }

  1662. 

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

  1664. }

  1665. #endif

  1666. 

  1667. // -----------------------------------------------------------------------

  1668. // Bridge/Controller OSC stuff

  1669. 

  1670. #ifdef BUILD_BRIDGE

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

  1672. {

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

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

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

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

  1677. 

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

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

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

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

  1682. }

  1683. 

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

  1685. {

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

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

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

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

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

  1691.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  1692.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  1694. 

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

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

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

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

  1699. }

  1700. 

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

  1702. {

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

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

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

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

  1707. 

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

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

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

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

  1712. }

  1713. 

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

  1715. {

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

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

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

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

  1720. 

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

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

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

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

  1725. }

  1726. 

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

  1728. {

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

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

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

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

  1733. 

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

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

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

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

  1738. }

  1739. 

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

  1741. {

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

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

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

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

  1746. 

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

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

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

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

  1751. }

  1752. 

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

  1754. {

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

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

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

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

  1759. 

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

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

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

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

  1764. }

  1765. 

  1766. 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

  1767. {

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

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

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

  1771.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  1772.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  1774. 

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

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

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

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

  1779. }

  1780. 

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

  1782. {

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

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

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

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

  1787. 

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

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

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

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

  1792. }

  1793. 

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

  1795. {

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

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

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

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

  1800. 

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

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

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

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

  1805. }

  1806. 

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

  1808. {

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

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

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

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

  1813. 

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

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

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

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

  1818. }

  1819. 

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

  1821. {

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

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

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

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

  1826. 

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

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

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

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

  1831. }

  1832. 

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

  1834. {

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

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

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

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

  1839. 

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

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

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

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

  1844. }

  1845. 

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

  1847. {

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

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

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

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

  1852. 

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

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

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

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

  1857. }

  1858. 

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

  1860. {

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

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

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

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

  1865. 

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

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

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

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

  1870. }

  1871. 

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

  1873. {

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

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

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

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

  1878. 

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

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

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

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

  1883. }

  1884. 

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

  1886. {

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

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

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

  1890.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  1892. 

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

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

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

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

  1897. }

  1898. 

  1899. 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

  1900. {

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

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

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

  1904.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  1906. 

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

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

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

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

  1911. }

  1912. 

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

  1914. {

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

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

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

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

  1919.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1921. 

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

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

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

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

  1926. }

  1927. 

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

  1929. {

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

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

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

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

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

  1935.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1937. 

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

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

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

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

  1942. }

  1943. 

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

  1945. {

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

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

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

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

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

  1951. 

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

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

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

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

  1956. }

  1957. 

  1958. void CarlaEngine::oscSend_bridge_pong() const noexcept

  1959. {

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

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

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

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

  1964. 

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

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

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

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

  1969. }

  1970. #else

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

  1972. {

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

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

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

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

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

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

  1979. 

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

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

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

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

  1984. }

  1985. 

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

  1987. {

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

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

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

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

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

  1993. 

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

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

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

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

  1998. }

  1999. 

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

  2001. {

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

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

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

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

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

  2007. 

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

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

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

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

  2012. }

  2013. 

  2014. 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

  2015. {

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

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

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

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

  2020.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

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

  2022. 

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

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

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

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

  2027. }

  2028. 

  2029. 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

  2030. {

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

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

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

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

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

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

  2037.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  2038.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  2040. 

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

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

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

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

  2045. }

  2046. 

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

  2048. {

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

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

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

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

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

  2054. 

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

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

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

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

  2059. }

  2060. 

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

  2062. {

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

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

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

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

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

  2068. 

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

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

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

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

  2073. }

  2074. 

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

  2076. {

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

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

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

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

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

  2082. 

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

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

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

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

  2087. }

  2088. 

  2089. void CarlaEngine::oscSend_control_set_program_count(const uint pluginId, const uint32_t count) const noexcept

  2090. {

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

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

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

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

  2095.     carla_debug("CarlaEngine::oscSend_control_set_program_count(%i, %i)", pluginId, count);

  2096. 

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

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

  2099.     std::strcat(targetPath, "/set_program_count");

  2100.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), static_cast<int32_t>(count));

  2101. }

  2102. 

  2103. void CarlaEngine::oscSend_control_set_midi_program_count(const uint pluginId, const uint32_t count) const noexcept

  2104. {

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

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

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

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

  2109.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_count(%i, %i)", pluginId, count);

  2110. 

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

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

  2113.     std::strcat(targetPath, "/set_midi_program_count");

  2114.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), static_cast<int32_t>(count));

  2115. }

  2116. 

  2117. 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

  2118. {

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

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

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

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

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

  2124.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

  2125.     carla_debug("CarlaEngine::oscSend_control_set_parameter_data(%i, %i, %i:%s, %X, \"%s\", \"%s\")", pluginId, index, type, ParameterType2Str(type), hints, name, unit);

  2126. 

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

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

  2129.     std::strcat(targetPath, "/set_parameter_data");

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

  2131. }

  2132. 

  2133. 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

  2134. {

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

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

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

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

  2139.     CARLA_SAFE_ASSERT_RETURN(def <= min && def >= max,);

  2140.     CARLA_SAFE_ASSERT_RETURN(min < max,);

  2141.     carla_debug("CarlaEngine::oscSend_control_set_parameter_ranges1(%i, %i, %f, %f, %f)", pluginId, index, def, min, max, def);

  2142. 

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

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

  2145.     std::strcat(targetPath, "/set_parameter_ranges1");

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

  2147. }

  2148. 

  2149. 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

  2150. {

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

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

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

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

  2155.     CARLA_SAFE_ASSERT_RETURN(step <= stepSmall && step >= stepLarge,);

  2156.     CARLA_SAFE_ASSERT_RETURN(stepSmall <= stepLarge,);

  2157.     carla_debug("CarlaEngine::oscSend_control_set_parameter_ranges2(%i, %i, %f, %f, %f)", pluginId, index, step, stepSmall, stepLarge);

  2158. 

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

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

  2161.     std::strcat(targetPath, "/set_parameter_ranges");

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

  2163. }

  2164. 

  2165. void CarlaEngine::oscSend_control_set_parameter_midi_cc(const uint pluginId, const uint32_t index, const int16_t cc) const noexcept

  2166. {

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

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

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

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

  2171.     CARLA_SAFE_ASSERT_RETURN(cc <= 0x5F,);

  2172.     carla_debug("CarlaEngine::oscSend_control_set_parameter_midi_cc(%i, %i, %i)", pluginId, index, cc);

  2173. 

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

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

  2176.     std::strcat(targetPath, "/set_parameter_midi_cc");

  2177.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(cc));

  2178. }

  2179. 

  2180. void CarlaEngine::oscSend_control_set_parameter_midi_channel(const uint pluginId, const uint32_t index, const uint8_t channel) const noexcept

  2181. {

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

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

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

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

  2186.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2187.     carla_debug("CarlaEngine::oscSend_control_set_parameter_midi_channel(%i, %i, %i)", pluginId, index, channel);

  2188. 

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

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

  2191.     std::strcat(targetPath, "/set_parameter_midi_channel");

  2192.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(channel));

  2193. }

  2194. 

  2195. void CarlaEngine::oscSend_control_set_parameter_value(const uint pluginId, const int32_t index, const float value) const noexcept

  2196. {

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

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

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

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

  2201.     CARLA_SAFE_ASSERT_RETURN(index != PARAMETER_NULL,);

  2202.     carla_debug("CarlaEngine::oscSend_control_set_parameter_value(%i, %i:%s, %f)", pluginId, index, (index < 0) ? InternalParameterIndex2Str(static_cast<InternalParameterIndex>(index)) : "(none)", value);

  2203. 

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

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

  2206.     std::strcat(targetPath, "/set_parameter_value");

  2207.     try_lo_send(pData->oscData->target, targetPath, "iif", static_cast<int32_t>(pluginId), index, value);

  2208. }

  2209. 

  2210. void CarlaEngine::oscSend_control_set_default_value(const uint pluginId, const uint32_t index, const float value) const noexcept

  2211. {

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

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

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

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

  2216.     carla_debug("CarlaEngine::oscSend_control_set_default_value(%i, %i, %f)", pluginId, index, value);

  2217. 

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

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

  2220.     std::strcat(targetPath, "/set_default_value");

  2221.     try_lo_send(pData->oscData->target, targetPath, "iif", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), value);

  2222. }

  2223. 

  2224. void CarlaEngine::oscSend_control_set_current_program(const uint pluginId, const int32_t index) const noexcept

  2225. {

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

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

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

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

  2230.     carla_debug("CarlaEngine::oscSend_control_set_current_program(%i, %i)", pluginId, index);

  2231. 

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

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

  2234.     std::strcat(targetPath, "/set_current_program");

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

  2236. }

  2237. 

  2238. void CarlaEngine::oscSend_control_set_current_midi_program(const uint pluginId, const int32_t index) const noexcept

  2239. {

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

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

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

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

  2244.     carla_debug("CarlaEngine::oscSend_control_set_current_midi_program(%i, %i)", pluginId, index);

  2245. 

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

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

  2248.     std::strcat(targetPath, "/set_current_midi_program");

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

  2250. }

  2251. 

  2252. void CarlaEngine::oscSend_control_set_program_name(const uint pluginId, const uint32_t index, const char* const name) const noexcept

  2253. {

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

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

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

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

  2258.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2259.     carla_debug("CarlaEngine::oscSend_control_set_program_name(%i, %i, \"%s\")", pluginId, index, name);

  2260. 

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

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

  2263.     std::strcat(targetPath, "/set_program_name");

  2264.     try_lo_send(pData->oscData->target, targetPath, "iis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), name);

  2265. }

  2266. 

  2267. 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

  2268. {

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

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

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

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

  2273.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2274.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_data(%i, %i, %i, %i, \"%s\")", pluginId, index, bank, program, name);

  2275. 

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

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

  2278.     std::strcat(targetPath, "/set_midi_program_data");

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

  2280. }

  2281. 

  2282. void CarlaEngine::oscSend_control_note_on(const uint pluginId, const uint8_t channel, const uint8_t note, const uint8_t velo) const noexcept

  2283. {

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

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

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

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

  2288.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2289.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2290.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2291.     carla_debug("CarlaEngine::oscSend_control_note_on(%i, %i, %i, %i)", pluginId, channel, note, velo);

  2292. 

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

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

  2295.     std::strcat(targetPath, "/note_on");

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

  2297. }

  2298. 

  2299. void CarlaEngine::oscSend_control_note_off(const uint pluginId, const uint8_t channel, const uint8_t note) const noexcept

  2300. {

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

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

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

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

  2305.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2306.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2307.     carla_debug("CarlaEngine::oscSend_control_note_off(%i, %i, %i)", pluginId, channel, note);

  2308. 

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

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

  2311.     std::strcat(targetPath, "/note_off");

  2312.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(channel), static_cast<int32_t>(note));

  2313. }

  2314. 

  2315. void CarlaEngine::oscSend_control_set_peaks(const uint pluginId) const noexcept

  2316. {

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

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

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

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

  2321. 

  2322.     // TODO - try and see if we can get peaks[4] ref

  2323.     const EnginePluginData& epData(pData->plugins[pluginId]);

  2324. 

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

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

  2327.     std::strcat(targetPath, "/set_peaks");

  2328.     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]);

  2329. }

  2330. 

  2331. void CarlaEngine::oscSend_control_exit() const noexcept

  2332. {

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

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

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

  2336.     carla_debug("CarlaEngine::oscSend_control_exit()");

  2337. 

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

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

  2340.     std::strcat(targetPath, "/exit");

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

  2342. }

  2343. #endif

  2344. 

  2345. // -----------------------------------------------------------------------

  2346. 

  2347. CARLA_BACKEND_END_NAMESPACE