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

2322 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.     count += getJuceApiCount();

  85. #endif

  86. 

  87.     return count;

  88. }

  89. 

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

  91. {

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

  93. 

  94.     uint index(index2);

  95. 

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

  97.         return "JACK";

  98. 

  99. #ifndef BUILD_BRIDGE

  100.     if (index < getRtAudioApiCount())

  101.         return getRtAudioApiName(index);

  102. 

  103.     index -= getRtAudioApiCount();

  104. 

  105.     if (index < getJuceApiCount())

  106.         return getJuceApiName(index);

  107. #endif

  108. 

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

  110.     return nullptr;

  111. }

  112. 

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

  114. {

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

  116. 

  117.     uint index(index2);

  118. 

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

  120.     {

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

  122.         return ret;

  123.     }

  124. 

  125. #ifndef BUILD_BRIDGE

  126.     if (index < getRtAudioApiCount())

  127.         return getRtAudioApiDeviceNames(index);

  128. 

  129.     index -= getRtAudioApiCount();

  130. 

  131.     if (index < getJuceApiCount())

  132.         return getJuceApiDeviceNames(index);

  133. #endif

  134. 

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

  136.     return nullptr;

  137. }

  138. 

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

  140. {

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

  142. 

  143.     uint index(index2);

  144. 

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

  146.     {

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

  148.         static EngineDriverDeviceInfo devInfo;

  149.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  150.         devInfo.bufferSizes = bufSizes;

  151.         devInfo.sampleRates = nullptr;

  152.         return &devInfo;

  153.     }

  154. 

  155. #ifndef BUILD_BRIDGE

  156.     if (index < getRtAudioApiCount())

  157.         return getRtAudioDeviceInfo(index, deviceName);

  158. 

  159.     index -= getRtAudioApiCount();

  160. 

  161.     if (index < getJuceApiCount())

  162.         return getJuceDeviceInfo(index, deviceName);

  163. #endif

  164. 

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

  166.     return nullptr;

  167. }

  168. 

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

  170. {

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

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

  173. 

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

  175.         return newJack();

  176. 

  177. #ifndef BUILD_BRIDGE

  178.     // -------------------------------------------------------------------

  179.     // common

  180. 

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

  182.         return newRtAudio(AUDIO_API_JACK);

  183. 

  184.     // -------------------------------------------------------------------

  185.     // linux

  186. 

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

  188.         //return newJuce(AUDIO_API_ALSA);

  189.         return newRtAudio(AUDIO_API_ALSA);

  190. 

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

  192.         return newRtAudio(AUDIO_API_OSS);

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

  194.         return newRtAudio(AUDIO_API_PULSE);

  195. 

  196.     // -------------------------------------------------------------------

  197.     // macos

  198. 

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

  200.         return newJuce(AUDIO_API_CORE);

  201. 

  202.     // -------------------------------------------------------------------

  203.     // windows

  204. 

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

  206.         return newJuce(AUDIO_API_ASIO);

  207. 

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

  209.         return newJuce(AUDIO_API_DS);

  210. #endif

  211. 

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

  213.     return nullptr;

  214. }

  215. 

  216. // -----------------------------------------------------------------------

  217. // Maximum values

  218. 

  219. uint CarlaEngine::getMaxClientNameSize() const noexcept

  220. {

  221.     return STR_MAX/2;

  222. }

  223. 

  224. uint CarlaEngine::getMaxPortNameSize() const noexcept

  225. {

  226.     return STR_MAX;

  227. }

  228. 

  229. uint CarlaEngine::getCurrentPluginCount() const noexcept

  230. {

  231.     return pData->curPluginCount;

  232. }

  233. 

  234. uint CarlaEngine::getMaxPluginNumber() const noexcept

  235. {

  236.     return pData->maxPluginNumber;

  237. }

  238. 

  239. // -----------------------------------------------------------------------

  240. // Virtual, per-engine type calls

  241. 

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

  243. {

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

  245. 

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

  247.         return false;

  248. 

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

  250.     return true;

  251. }

  252. 

  253. bool CarlaEngine::close()

  254. {

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

  256. 

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

  258.     {

  259.         pData->aboutToClose = true;

  260.         removeAllPlugins();

  261.     }

  262. 

  263. #ifndef BUILD_BRIDGE

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

  265.         oscSend_control_exit();

  266. #endif

  267. 

  268.     pData->close();

  269. 

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

  271.     return true;

  272. }

  273. 

  274. void CarlaEngine::idle() noexcept

  275. {

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

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

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

  279. 

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

  281.     {

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

  283. 

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

  285.         {

  286.             try {

  287.                 plugin->idle();

  288.             } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin idle");

  289.         }

  290.     }

  291. 

  292.     pData->osc.idle();

  293. }

  294. 

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

  296. {

  297.     return new CarlaEngineClient(*this);

  298. }

  299. 

  300. // -----------------------------------------------------------------------

  301. // Plugin management

  302. 

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

  304. {

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

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

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

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

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

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

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

  312. 

  313.     uint id;

  314. 

  315. #ifndef BUILD_BRIDGE

  316.     CarlaPlugin* oldPlugin = nullptr;

  317. 

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

  319.     {

  320.         id = pData->nextPluginId;

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

  322. 

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

  324. 

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

  326.     }

  327.     else

  328. #endif

  329.     {

  330.         id = pData->curPluginCount;

  331. 

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

  333.         {

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

  335.             return false;

  336.         }

  337. 

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

  339.     }

  340. 

  341.     CarlaPlugin::Initializer initializer = {

  342.         this,

  343.         id,

  344.         filename,

  345.         name,

  346.         label,

  347.         uniqueId

  348.     };

  349. 

  350.     CarlaPlugin* plugin = nullptr;

  351. 

  352. #ifndef BUILD_BRIDGE

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

  354. 

  355.     if (bridgeBinary.isNotEmpty())

  356.     {

  357. # ifndef CARLA_OS_WIN

  358.         if (btype == BINARY_NATIVE)

  359.         {

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

  361.         }

  362.         else

  363. # endif

  364.         {

  365.             switch (btype)

  366.             {

  367.             case BINARY_POSIX32:

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

  369.                 break;

  370.             case BINARY_POSIX64:

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

  372.                 break;

  373.             case BINARY_WIN32:

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

  375.                 break;

  376.             case BINARY_WIN64:

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

  378.                 break;

  379.             default:

  380.                 bridgeBinary.clear();

  381.                 break;

  382.             }

  383.         }

  384. 

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

  386. 

  387.         if (! file.existsAsFile())

  388.             bridgeBinary.clear();

  389.     }

  390. 

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

  392.     {

  393.         if (bridgeBinary.isNotEmpty())

  394.         {

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

  396.         }

  397. # ifdef CARLA_OS_LINUX

  398.         else if (btype == BINARY_WIN32)

  399.         {

  400.             // fallback to dssi-vst

  401.             File file(filename);

  402. 

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

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

  405. 

  406.             CarlaPlugin::Initializer init2 = {

  407.                 this,

  408.                 id,

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

  410.                 name,

  411.                 label2,

  412.                 uniqueId

  413.             };

  414. 

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

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

  417. 

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

  419. 

  420.             if (oldVstPath != nullptr)

  421.                 carla_setenv("VST_PATH", oldVstPath);

  422.         }

  423. # endif

  424.         else

  425.         {

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

  427.             return false;

  428.         }

  429.     }

  430.     else

  431. #endif // ! BUILD_BRIDGE

  432.     {

  433.         bool use16Outs;

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

  435. 

  436.         switch (ptype)

  437.         {

  438.         case PLUGIN_NONE:

  439.             break;

  440. 

  441.         case PLUGIN_INTERNAL:

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

  443.             {

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

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

  446.             }

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

  448.             {

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

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

  451.             }

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

  453.             {

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

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

  456.             }

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

  458.             {

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

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

  461.             }

  462.             else

  463.             {

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

  465.             }

  466.             break;

  467. 

  468.         case PLUGIN_LADSPA:

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

  470.             break;

  471. 

  472.         case PLUGIN_DSSI:

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

  474.             break;

  475. 

  476.         case PLUGIN_LV2:

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

  478.             break;

  479. 

  480.         case PLUGIN_VST:

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

  482.             break;

  483. 

  484.         case PLUGIN_VST3:

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

  486.             break;

  487. 

  488.         case PLUGIN_AU:

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

  490.             break;

  491. 

  492.         case PLUGIN_GIG:

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

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

  495.             break;

  496. 

  497.         case PLUGIN_SF2:

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

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

  500.             break;

  501. 

  502.         case PLUGIN_SFZ:

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

  504.             break;

  505.         }

  506.     }

  507. 

  508.     if (plugin == nullptr)

  509.     {

  510. #ifndef BUILD_BRIDGE

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

  512. #endif

  513.         return false;

  514.     }

  515. 

  516.     plugin->registerToOscClient();

  517. 

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

  519.     pluginData.plugin      = plugin;

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

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

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

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

  524. 

  525. #ifndef BUILD_BRIDGE

  526.     if (oldPlugin != nullptr)

  527.     {

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

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

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

  531. 

  532.         delete oldPlugin;

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

  534. 

  535.         if (wasActive)

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

  537. 

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

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

  540. 

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

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

  543.     }

  544.     else

  545. #endif

  546.     {

  547.         ++pData->curPluginCount;

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

  549. 

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

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

  552.     }

  553. 

  554.     return true;

  555. }

  556. 

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

  558. {

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

  560. }

  561. 

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

  563. {

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

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

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

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

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

  569. 

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

  571. 

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

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

  574. 

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

  576. 

  577. #ifndef BUILD_BRIDGE

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

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

  580. 

  581.     if (isOscControlRegistered())

  582.         oscSend_control_remove_plugin(id);

  583. #else

  584.     pData->plugins[0].plugin = nullptr;

  585. #endif

  586. 

  587.     delete plugin;

  588. 

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

  590.         pData->thread.startThread();

  591. 

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

  593.     return true;

  594. }

  595. 

  596. bool CarlaEngine::removeAllPlugins()

  597. {

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

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

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

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

  602. 

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

  604.         return true;

  605. 

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

  607. 

  608.     const bool lockWait(isRunning());

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

  610. 

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

  612. 

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

  614.     {

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

  616. 

  617.         if (pluginData.plugin != nullptr)

  618.         {

  619.             delete pluginData.plugin;

  620.             pluginData.plugin = nullptr;

  621.         }

  622. 

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

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

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

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

  627. 

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

  629.     }

  630. 

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

  632.         pData->thread.startThread();

  633. 

  634.     return true;

  635. }

  636. 

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

  638. {

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

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

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

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

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

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

  645. 

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

  647. 

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

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

  650. 

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

  652.     {

  653.         plugin->setName(name);

  654.         return name;

  655.     }

  656. 

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

  658.     return nullptr;

  659. }

  660. 

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

  662. {

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

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

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

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

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

  668. 

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

  670. 

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

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

  673. 

  674.     char label[STR_MAX+1];

  675.     carla_zeroChar(label, STR_MAX+1);

  676.     plugin->getLabel(label);

  677. 

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

  679. 

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

  681.         return false;

  682. 

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

  684. 

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

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

  687. 

  688.     return true;

  689. }

  690. 

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

  692. {

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

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

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

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

  697. 

  698.     // might use this to reset

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

  700.     {

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

  702.         return true;

  703.     }

  704. 

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

  706. 

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

  708. 

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

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

  711. 

  712.     pData->nextPluginId = id;

  713. 

  714.     return true;

  715. }

  716. 

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

  718. {

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

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

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

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

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

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

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

  726. 

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

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

  729. 

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

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

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

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

  734. 

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

  736. 

  737. #ifndef BUILD_BRIDGE

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

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

  740. 

  741.     // TODO

  742.     //if (isOscControlRegistered())

  743.     //    oscSend_control_switch_plugins(idA, idB);

  744. #else

  745.     pData->plugins[0].plugin = nullptr;

  746. #endif

  747. 

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

  749.         pData->thread.startThread();

  750. 

  751.     return true;

  752. }

  753. 

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

  755. {

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

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

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

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

  760. 

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

  762. }

  763. 

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

  765. {

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

  767. }

  768. 

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

  770. {

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

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

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

  774. 

  775.     CarlaString sname;

  776.     sname = name;

  777. 

  778.     if (sname.isEmpty())

  779.     {

  780.         sname = "(No name)";

  781.         return sname.dup();

  782.     }

  783. 

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

  785. 

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

  787.         return sname.dup();

  788. 

  789.     sname.truncate(maxNameSize);

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

  791. 

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

  793.     {

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

  795. 

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

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

  798.         {

  799.             if (sname != pluginName)

  800.                 continue;

  801.         }

  802. 

  803.         // Check if string has already been modified

  804.         {

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

  806. 

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

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

  809.             {

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

  811. 

  812.                 if (number == 9)

  813.                 {

  814.                     // next number is 10, 2 digits

  815.                     sname.truncate(len-4);

  816.                     sname += " (10)";

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

  818.                 }

  819.                 else

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

  821. 

  822.                 continue;

  823.             }

  824. 

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

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

  827.             {

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

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

  830. 

  831.                 if (n2 == '9')

  832.                 {

  833.                     n2 = '0';

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

  835.                 }

  836.                 else

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

  838. 

  839.                 sname[len-2] = n2;

  840.                 sname[len-3] = n3;

  841. 

  842.                 continue;

  843.             }

  844.         }

  845. 

  846.         // Modify string if not

  847.         sname += " (2)";

  848.     }

  849. 

  850.     return sname.dup();

  851. }

  852. 

  853. // -----------------------------------------------------------------------

  854. // Project management

  855. 

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

  857. {

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

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

  860. 

  861.     File file(filename);

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

  863. 

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

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

  866.     extension.toLower();

  867. 

  868.     // -------------------------------------------------------------------

  869. 

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

  871.         return loadProject(filename);

  872. 

  873.     // -------------------------------------------------------------------

  874. 

  875.     if (extension == "gig")

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

  877. 

  878.     if (extension == "sf2")

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

  880. 

  881.     if (extension == "sfz")

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

  883. 

  884.     // -------------------------------------------------------------------

  885. 

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

  887.     {

  888. #ifdef WANT_AUDIOFILE

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

  890.         {

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

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

  893.             return true;

  894.         }

  895.         return false;

  896. #else

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

  898.         return false;

  899. #endif

  900.     }

  901. 

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

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

  904.     {

  905. #ifdef WANT_AUDIOFILE

  906. # ifdef HAVE_FFMPEG

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

  908.         {

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

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

  911.             return true;

  912.         }

  913.         return false;

  914. # else

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

  916.         return false;

  917. # endif

  918. #else

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

  920.         return false;

  921. #endif

  922.     }

  923. 

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

  925. 

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

  927.     {

  928. #ifdef WANT_MIDIFILE

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

  930.         {

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

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

  933.             return true;

  934.         }

  935.         return false;

  936. #else

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

  938.         return false;

  939. #endif

  940.     }

  941. 

  942.     // -------------------------------------------------------------------

  943.     // ZynAddSubFX

  944. 

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

  946.     {

  947. #ifdef WANT_ZYNADDSUBFX

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

  949.         {

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

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

  952.             return true;

  953.         }

  954.         return false;

  955. #else

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

  957.         return false;

  958. #endif

  959.     }

  960. 

  961.     // -------------------------------------------------------------------

  962. 

  963.     setLastError("Unknown file extension");

  964.     return false;

  965. }

  966. 

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

  968. {

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

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

  971. 

  972.     File file(filename);

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

  974. 

  975.     XmlDocument xml(file);

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

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

  978. 

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

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

  981. 

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

  983.     {

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

  985.         return false;

  986.     }

  987. 

  988.     // completely load file

  989.     xmlElement = xml.getDocumentElement(false);

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

  991. 

  992.     // handle plugins first

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

  994.     {

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

  996. 

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

  998.         {

  999.             StateSave stateSave;

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

  1001. 

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

  1003. 

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

  1005. 

  1006.             const void* extraStuff = nullptr;

  1007. 

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

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

  1010. 

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

  1012. 

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

  1014.             {

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

  1016.                     extraStuff = "true";

  1017.             }

  1018. 

  1019.             // TODO - proper find&load plugins

  1020. 

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

  1022.             {

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

  1024.                     plugin->loadStateSave(stateSave);

  1025.             }

  1026.             else

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

  1028.         }

  1029. 

  1030.         if (isPreset)

  1031.             return true;

  1032.     }

  1033. 

  1034. #ifndef BUILD_BRIDGE

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

  1036. 

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

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

  1039.     {

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

  1041.             return true;

  1042.     }

  1043. 

  1044.     // now handle connections

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

  1046.     {

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

  1048. 

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

  1050.         {

  1051.             CarlaString sourcePort, targetPort;

  1052. 

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

  1054.             {

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

  1056. 

  1057.                 sourcePort.clear();

  1058.                 targetPort.clear();

  1059. 

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

  1061.                     continue;

  1062. 

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

  1064.                 {

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

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

  1067. 

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

  1069.                         sourcePort = text.toRawUTF8();

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

  1071.                         targetPort = text.toRawUTF8();

  1072.                 }

  1073. 

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

  1075.                     restorePatchbayConnection(sourcePort, targetPort);

  1076.             }

  1077.             break;

  1078.         }

  1079.     }

  1080. #endif

  1081. 

  1082.     return true;

  1083. }

  1084. 

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

  1086. {

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

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

  1089. 

  1090.     MemoryOutputStream out;

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

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

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

  1094. 

  1095.     bool firstPlugin = true;

  1096.     char strBuf[STR_MAX+1];

  1097. 

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

  1099.     {

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

  1101. 

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

  1103.         {

  1104.             if (! firstPlugin)

  1105.                 out << "\n";

  1106. 

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

  1108. 

  1109.             plugin->getRealName(strBuf);

  1110. 

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

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

  1113. 

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

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

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

  1117. 

  1118.             firstPlugin = false;

  1119.         }

  1120.     }

  1121. 

  1122. #ifndef BUILD_BRIDGE

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

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

  1125.     {

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

  1127.             return true;

  1128.     }

  1129. 

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

  1131.     {

  1132.         if (! firstPlugin)

  1133.             out << "\n";

  1134. 

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

  1136. 

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

  1138.         {

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

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

  1141. 

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

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

  1144. 

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

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

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

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

  1149. 

  1150.             delete[] connSource;

  1151.             delete[] connTarget;

  1152.         }

  1153. 

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

  1155.     }

  1156. #endif

  1157. 

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

  1159. 

  1160.     File file(filename);

  1161. 

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

  1163.         return true;

  1164. 

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

  1166.     return false;

  1167. }

  1168. 

  1169. // -----------------------------------------------------------------------

  1170. // Information (base)

  1171. 

  1172. uint CarlaEngine::getHints() const noexcept

  1173. {

  1174.     return pData->hints;

  1175. }

  1176. 

  1177. uint32_t CarlaEngine::getBufferSize() const noexcept

  1178. {

  1179.     return pData->bufferSize;

  1180. }

  1181. 

  1182. double CarlaEngine::getSampleRate() const noexcept

  1183. {

  1184.     return pData->sampleRate;

  1185. }

  1186. 

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

  1188. {

  1189.     return pData->name;

  1190. }

  1191. 

  1192. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1193. {

  1194.     return pData->options.processMode;

  1195. }

  1196. 

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

  1198. {

  1199.     return pData->options;

  1200. }

  1201. 

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

  1203. {

  1204.     return pData->timeInfo;

  1205. }

  1206. 

  1207. // -----------------------------------------------------------------------

  1208. // Information (peaks)

  1209. 

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

  1211. {

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

  1213. 

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

  1215. }

  1216. 

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

  1218. {

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

  1220. 

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

  1222. }

  1223. 

  1224. // -----------------------------------------------------------------------

  1225. // Callback

  1226. 

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

  1228. {

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

  1230. 

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

  1232.     {

  1233.         try {

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

  1235.         } catch(...) {}

  1236.     }

  1237. }

  1238. 

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

  1240. {

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

  1242. 

  1243.     pData->callback    = func;

  1244.     pData->callbackPtr = ptr;

  1245. }

  1246. 

  1247. // -----------------------------------------------------------------------

  1248. // File Callback

  1249. 

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

  1251. {

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

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

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

  1255. 

  1256.     const char* ret = nullptr;

  1257. 

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

  1259.     {

  1260.         try {

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

  1262.         } catch(...) {}

  1263.     }

  1264. 

  1265.     return ret;

  1266. }

  1267. 

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

  1269. {

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

  1271. 

  1272.     pData->fileCallback    = func;

  1273.     pData->fileCallbackPtr = ptr;

  1274. }

  1275. 

  1276. #ifndef BUILD_BRIDGE

  1277. // -----------------------------------------------------------------------

  1278. // Patchbay

  1279. 

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

  1281. {

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

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

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

  1285. 

  1286.     if (pData->graph.isRack)

  1287.     {

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

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

  1290.     }

  1291.     else

  1292.     {

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

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

  1295.     }

  1296. }

  1297. 

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

  1299. {

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

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

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

  1303. 

  1304.     if (pData->graph.isRack)

  1305.     {

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

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

  1308.     }

  1309.     else

  1310.     {

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

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

  1313.     }

  1314. }

  1315. 

  1316. bool CarlaEngine::patchbayRefresh()

  1317. {

  1318.     setLastError("Unsupported operation");

  1319.     return false;

  1320. }

  1321. #endif

  1322. 

  1323. // -----------------------------------------------------------------------

  1324. // Transport

  1325. 

  1326. void CarlaEngine::transportPlay() noexcept

  1327. {

  1328.     pData->time.playing = true;

  1329. }

  1330. 

  1331. void CarlaEngine::transportPause() noexcept

  1332. {

  1333.     pData->time.playing = false;

  1334. }

  1335. 

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

  1337. {

  1338.     pData->time.frame = frame;

  1339. }

  1340. 

  1341. // -----------------------------------------------------------------------

  1342. // Error handling

  1343. 

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

  1345. {

  1346.     return pData->lastError;

  1347. }

  1348. 

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

  1350. {

  1351.     pData->lastError = error;

  1352. }

  1353. 

  1354. void CarlaEngine::setAboutToClose() noexcept

  1355. {

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

  1357. 

  1358.     pData->aboutToClose = true;

  1359. }

  1360. 

  1361. // -----------------------------------------------------------------------

  1362. // Global options

  1363. 

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

  1365. {

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

  1367. 

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

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

  1370. 

  1371.     switch (option)

  1372.     {

  1373.     case ENGINE_OPTION_DEBUG:

  1374.     case ENGINE_OPTION_NSM_INIT:

  1375.         break;

  1376. 

  1377.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1380.         break;

  1381. 

  1382.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1385.         break;

  1386. 

  1387.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1390.         break;

  1391. 

  1392.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1395.         break;

  1396. 

  1397.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1400.         break;

  1401. 

  1402.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1405.         break;

  1406. 

  1407.     case ENGINE_OPTION_MAX_PARAMETERS:

  1408.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1410.         break;

  1411. 

  1412.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1413.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1415.         break;

  1416. 

  1417.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1420.         break;

  1421. 

  1422.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1423.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1425.         break;

  1426. 

  1427.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1428.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1430.         break;

  1431. 

  1432.     case ENGINE_OPTION_AUDIO_DEVICE:

  1433.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1434. 

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

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

  1437. 

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

  1439.         break;

  1440. 

  1441.     case ENGINE_OPTION_PATH_BINARIES:

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

  1443. 

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

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

  1446. 

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

  1448.         break;

  1449. 

  1450.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1452. 

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

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

  1455. 

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

  1457.         break;

  1458. 

  1459.     case ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1462.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1464.         break;

  1465.     }

  1466. }

  1467. 

  1468. // -----------------------------------------------------------------------

  1469. // OSC Stuff

  1470. 

  1471. #ifdef BUILD_BRIDGE

  1472. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1473. {

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

  1475. }

  1476. #else

  1477. bool CarlaEngine::isOscControlRegistered() const noexcept

  1478. {

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

  1480. }

  1481. #endif

  1482. 

  1483. void CarlaEngine::idleOsc() const noexcept

  1484. {

  1485.     pData->osc.idle();

  1486. }

  1487. 

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

  1489. {

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

  1491. }

  1492. 

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

  1494. {

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

  1496. }

  1497. 

  1498. #ifdef BUILD_BRIDGE

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

  1500. {

  1501.     pData->oscData = oscData;

  1502. }

  1503. #endif

  1504. 

  1505. // -----------------------------------------------------------------------

  1506. // Helper functions

  1507. 

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

  1509. {

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

  1511. }

  1512. 

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

  1514. {

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

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

  1517. 

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

  1519. }

  1520. 

  1521. // -----------------------------------------------------------------------

  1522. // Internal stuff

  1523. 

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

  1525. {

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

  1527. 

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

  1529.     {

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

  1531. 

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

  1533.             plugin->bufferSizeChanged(newBufferSize);

  1534.     }

  1535. 

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

  1537. }

  1538. 

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

  1540. {

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

  1542. 

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

  1544.     {

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

  1546. 

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

  1548.             plugin->sampleRateChanged(newSampleRate);

  1549.     }

  1550. 

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

  1552. }

  1553. 

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

  1555. {

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

  1557. 

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

  1559.     {

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

  1561. 

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

  1563.             plugin->offlineModeChanged(isOfflineNow);

  1564.     }

  1565. }

  1566. 

  1567. void CarlaEngine::runPendingRtEvents() noexcept

  1568. {

  1569.     pData->doNextPluginAction(true);

  1570. 

  1571.     if (pData->time.playing)

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

  1573. 

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

  1575.     {

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

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

  1578.     }

  1579. }

  1580. 

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

  1582. {

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

  1584. 

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

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

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

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

  1589. }

  1590. 

  1591. #ifndef BUILD_BRIDGE

  1592. // -----------------------------------------------------------------------

  1593. // Patchbay stuff

  1594. 

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

  1596. {

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

  1598. 

  1599.     if (pData->graph.isRack)

  1600.     {

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

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

  1603.     }

  1604.     else

  1605.     {

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

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

  1608.     }

  1609. }

  1610. 

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

  1612. {

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

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

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

  1616. 

  1617.     uint groupA, portA;

  1618.     uint groupB, portB;

  1619. 

  1620.     if (pData->graph.isRack)

  1621.     {

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

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

  1624.             return;

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

  1626.             return;

  1627.     }

  1628.     else

  1629.     {

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

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

  1632.             return;

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

  1634.             return;

  1635.     }

  1636. 

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

  1638. }

  1639. #endif

  1640. 

  1641. // -----------------------------------------------------------------------

  1642. // Bridge/Controller OSC stuff

  1643. 

  1644. #ifdef BUILD_BRIDGE

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

  1646. {

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

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

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

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

  1651. 

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

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

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

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

  1656. }

  1657. 

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

  1659. {

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

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

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

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

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

  1665.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  1666.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  1668. 

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

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

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

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

  1673. }

  1674. 

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

  1676. {

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

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

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

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

  1681. 

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

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

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

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

  1686. }

  1687. 

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

  1689. {

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

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

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

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

  1694. 

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

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

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

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

  1699. }

  1700. 

  1701. void CarlaEngine::oscSend_bridge_parameter_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_parameter_count(%i, %i)", ins, outs);

  1707. 

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

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

  1710.     std::strcat(targetPath, "/bridge_parameter_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_program_count(const uint32_t count) 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_program_count(%i)", count);

  1720. 

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

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

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

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

  1725. }

  1726. 

  1727. void CarlaEngine::oscSend_bridge_midi_program_count(const uint32_t count) 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_midi_program_count(%i)", count);

  1733. 

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

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

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

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

  1738. }

  1739. 

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

  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_SAFE_ASSERT_RETURN(name != nullptr,);

  1746.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  1748. 

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

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

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

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

  1753. }

  1754. 

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

  1756. {

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

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

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

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

  1761. 

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

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

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

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

  1766. }

  1767. 

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

  1769. {

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

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

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

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

  1774. 

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

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

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

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

  1779. }

  1780. 

  1781. void CarlaEngine::oscSend_bridge_parameter_midi_cc(const uint32_t index, const int16_t cc) 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_midi_cc(%i, %i)", index, cc);

  1787. 

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

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

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

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

  1792. }

  1793. 

  1794. void CarlaEngine::oscSend_bridge_parameter_midi_channel(const uint32_t index, const uint8_t channel) 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_midi_channel(%i, %i)", index, channel);

  1800. 

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

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

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

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

  1805. }

  1806. 

  1807. void CarlaEngine::oscSend_bridge_parameter_value(const uint32_t index, const float value) 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_value(%i, %f)", index, value);

  1813. 

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

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

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

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

  1818. }

  1819. 

  1820. void CarlaEngine::oscSend_bridge_default_value(const uint32_t index, const float value) 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_default_value(%i, %f)", index, value);

  1826. 

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

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

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

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

  1831. }

  1832. 

  1833. void CarlaEngine::oscSend_bridge_current_program(const int32_t index) 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_current_program(%i)", index);

  1839. 

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

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

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

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

  1844. }

  1845. 

  1846. void CarlaEngine::oscSend_bridge_current_midi_program(const int32_t index) 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_current_midi_program(%i)", index);

  1852. 

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

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

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

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

  1857. }

  1858. 

  1859. void CarlaEngine::oscSend_bridge_program_name(const uint32_t index, const char* const name) 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_SAFE_ASSERT_RETURN(name != nullptr,);

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

  1866. 

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

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

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

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

  1871. }

  1872. 

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

  1874. {

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

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

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

  1878.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  1880. 

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

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

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

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

  1885. }

  1886. 

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

  1888. {

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

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

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

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

  1893.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1895. 

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

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

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

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

  1900. }

  1901. 

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

  1903. {

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

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

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

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

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

  1909.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1911. 

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

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

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

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

  1916. }

  1917. 

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

  1919. {

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

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

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

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

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

  1925. 

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

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

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

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

  1930. }

  1931. 

  1932. void CarlaEngine::oscSend_bridge_pong() const noexcept

  1933. {

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

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

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

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

  1938. 

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

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

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

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

  1943. }

  1944. #else

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

  1946. {

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

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

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

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

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

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

  1953. 

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

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

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

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

  1958. }

  1959. 

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

  1961. {

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

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

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

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

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

  1967. 

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

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

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

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

  1972. }

  1973. 

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

  1975. {

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

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

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

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

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

  1981. 

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

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

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

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

  1986. }

  1987. 

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

  1989. {

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

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

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

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

  1994.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

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

  1996. 

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

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

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

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

  2001. }

  2002. 

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

  2004. {

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

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

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

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

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

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

  2011.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  2012.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  2014. 

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

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

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

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

  2019. }

  2020. 

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

  2022. {

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

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

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

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

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

  2028. 

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

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

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

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

  2033. }

  2034. 

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

  2036. {

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

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

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

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

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

  2042. 

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

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

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

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

  2047. }

  2048. 

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

  2050. {

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

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

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

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

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

  2056. 

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

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

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

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

  2061. }

  2062. 

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

  2064. {

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

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

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

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

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

  2070. 

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

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

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

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

  2075. }

  2076. 

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

  2078. {

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

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

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

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

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

  2084. 

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

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

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

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

  2089. }

  2090. 

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

  2092. {

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

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

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

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

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

  2098.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  2100. 

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

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

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

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

  2105. }

  2106. 

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

  2108. {

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

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

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

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

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

  2114.     CARLA_SAFE_ASSERT_RETURN(min < max,);

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

  2116. 

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

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

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

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

  2121. }

  2122. 

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

  2124. {

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

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

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

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

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

  2130.     CARLA_SAFE_ASSERT_RETURN(stepSmall <= stepLarge,);

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

  2132. 

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

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

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

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

  2137. }

  2138. 

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

  2140. {

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

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

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

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

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

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

  2147. 

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

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

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

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

  2152. }

  2153. 

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

  2155. {

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

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

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

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

  2160.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  2162. 

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

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

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

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

  2167. }

  2168. 

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

  2170. {

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

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

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

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

  2175.     CARLA_SAFE_ASSERT_RETURN(index != PARAMETER_NULL,);

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

  2177. 

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

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

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

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

  2182. }

  2183. 

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

  2185. {

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

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

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

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

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

  2191. 

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

  2193.     std::strcpy(targetPath, pData->oscData->path);

  2194.     std::strcat(targetPath, "/set_default_value");

  2195.     try_lo_send(pData->oscData->target, targetPath, "iif", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), value);

  2196. }

  2197. 

  2198. void CarlaEngine::oscSend_control_set_current_program(const uint pluginId, const int32_t index) const noexcept

  2199. {

  2200.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2201.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2202.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2203.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2204.     carla_debug("CarlaEngine::oscSend_control_set_current_program(%i, %i)", pluginId, index);

  2205. 

  2206.     char targetPath[std::strlen(pData->oscData->path)+21];

  2207.     std::strcpy(targetPath, pData->oscData->path);

  2208.     std::strcat(targetPath, "/set_current_program");

  2209.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), index);

  2210. }

  2211. 

  2212. void CarlaEngine::oscSend_control_set_current_midi_program(const uint pluginId, const int32_t index) const noexcept

  2213. {

  2214.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2215.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2216.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2217.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2218.     carla_debug("CarlaEngine::oscSend_control_set_current_midi_program(%i, %i)", pluginId, index);

  2219. 

  2220.     char targetPath[std::strlen(pData->oscData->path)+26];

  2221.     std::strcpy(targetPath, pData->oscData->path);

  2222.     std::strcat(targetPath, "/set_current_midi_program");

  2223.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), index);

  2224. }

  2225. 

  2226. void CarlaEngine::oscSend_control_set_program_name(const uint pluginId, const uint32_t index, const char* const name) const noexcept

  2227. {

  2228.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2229.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2230.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2231.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2232.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2233.     carla_debug("CarlaEngine::oscSend_control_set_program_name(%i, %i, \"%s\")", pluginId, index, name);

  2234. 

  2235.     char targetPath[std::strlen(pData->oscData->path)+18];

  2236.     std::strcpy(targetPath, pData->oscData->path);

  2237.     std::strcat(targetPath, "/set_program_name");

  2238.     try_lo_send(pData->oscData->target, targetPath, "iis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), name);

  2239. }

  2240. 

  2241. 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

  2242. {

  2243.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2244.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2245.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2246.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2247.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2248.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_data(%i, %i, %i, %i, \"%s\")", pluginId, index, bank, program, name);

  2249. 

  2250.     char targetPath[std::strlen(pData->oscData->path)+23];

  2251.     std::strcpy(targetPath, pData->oscData->path);

  2252.     std::strcat(targetPath, "/set_midi_program_data");

  2253.     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);

  2254. }

  2255. 

  2256. void CarlaEngine::oscSend_control_note_on(const uint pluginId, const uint8_t channel, const uint8_t note, const uint8_t velo) const noexcept

  2257. {

  2258.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2259.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2260.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2261.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2262.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2263.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2264.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2265.     carla_debug("CarlaEngine::oscSend_control_note_on(%i, %i, %i, %i)", pluginId, channel, note, velo);

  2266. 

  2267.     char targetPath[std::strlen(pData->oscData->path)+9];

  2268.     std::strcpy(targetPath, pData->oscData->path);

  2269.     std::strcat(targetPath, "/note_on");

  2270.     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));

  2271. }

  2272. 

  2273. void CarlaEngine::oscSend_control_note_off(const uint pluginId, const uint8_t channel, const uint8_t note) const noexcept

  2274. {

  2275.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2276.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2277.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2278.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2279.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2280.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2281.     carla_debug("CarlaEngine::oscSend_control_note_off(%i, %i, %i)", pluginId, channel, note);

  2282. 

  2283.     char targetPath[std::strlen(pData->oscData->path)+10];

  2284.     std::strcpy(targetPath, pData->oscData->path);

  2285.     std::strcat(targetPath, "/note_off");

  2286.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(channel), static_cast<int32_t>(note));

  2287. }

  2288. 

  2289. void CarlaEngine::oscSend_control_set_peaks(const uint pluginId) const noexcept

  2290. {

  2291.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2292.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2293.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2294.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  2295. 

  2296.     // TODO - try and see if we can get peaks[4] ref

  2297.     const EnginePluginData& epData(pData->plugins[pluginId]);

  2298. 

  2299.     char targetPath[std::strlen(pData->oscData->path)+11];

  2300.     std::strcpy(targetPath, pData->oscData->path);

  2301.     std::strcat(targetPath, "/set_peaks");

  2302.     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]);

  2303. }

  2304. 

  2305. void CarlaEngine::oscSend_control_exit() const noexcept

  2306. {

  2307.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2308.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  2309.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  2310.     carla_debug("CarlaEngine::oscSend_control_exit()");

  2311. 

  2312.     char targetPath[std::strlen(pData->oscData->path)+6];

  2313.     std::strcpy(targetPath, pData->oscData->path);

  2314.     std::strcat(targetPath, "/exit");

  2315.     try_lo_send(pData->oscData->target, targetPath, "");

  2316. }

  2317. #endif

  2318. 

  2319. // -----------------------------------------------------------------------

  2320. 

  2321. CARLA_BACKEND_END_NAMESPACE