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

2225 lines
87KB
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. // -----------------------------------------------------------------------

  1277. // Transport

  1278. 

  1279. void CarlaEngine::transportPlay() noexcept

  1280. {

  1281.     pData->time.playing = true;

  1282. }

  1283. 

  1284. void CarlaEngine::transportPause() noexcept

  1285. {

  1286.     pData->time.playing = false;

  1287. }

  1288. 

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

  1290. {

  1291.     pData->time.frame = frame;

  1292. }

  1293. 

  1294. // -----------------------------------------------------------------------

  1295. // Error handling

  1296. 

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

  1298. {

  1299.     return pData->lastError;

  1300. }

  1301. 

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

  1303. {

  1304.     pData->lastError = error;

  1305. }

  1306. 

  1307. void CarlaEngine::setAboutToClose() noexcept

  1308. {

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

  1310. 

  1311.     pData->aboutToClose = true;

  1312. }

  1313. 

  1314. // -----------------------------------------------------------------------

  1315. // Global options

  1316. 

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

  1318. {

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

  1320. 

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

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

  1323. 

  1324.     switch (option)

  1325.     {

  1326.     case ENGINE_OPTION_DEBUG:

  1327.     case ENGINE_OPTION_NSM_INIT:

  1328.         break;

  1329. 

  1330.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1333.         break;

  1334. 

  1335.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1338.         break;

  1339. 

  1340.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1343.         break;

  1344. 

  1345.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1348.         break;

  1349. 

  1350.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1353.         break;

  1354. 

  1355.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1358.         break;

  1359. 

  1360.     case ENGINE_OPTION_MAX_PARAMETERS:

  1361.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1363.         break;

  1364. 

  1365.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1366.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1368.         break;

  1369. 

  1370.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1373.         break;

  1374. 

  1375.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1376.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1378.         break;

  1379. 

  1380.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1381.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1383.         break;

  1384. 

  1385.     case ENGINE_OPTION_AUDIO_DEVICE:

  1386.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1387. 

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

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

  1390. 

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

  1392.         break;

  1393. 

  1394.     case ENGINE_OPTION_PATH_BINARIES:

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

  1396. 

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

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

  1399. 

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

  1401.         break;

  1402. 

  1403.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1405. 

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

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

  1408. 

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

  1410.         break;

  1411. 

  1412.     case ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1415.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1417.         break;

  1418.     }

  1419. }

  1420. 

  1421. // -----------------------------------------------------------------------

  1422. // OSC Stuff

  1423. 

  1424. #ifdef BUILD_BRIDGE

  1425. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1426. {

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

  1428. }

  1429. #else

  1430. bool CarlaEngine::isOscControlRegistered() const noexcept

  1431. {

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

  1433. }

  1434. #endif

  1435. 

  1436. void CarlaEngine::idleOsc() const noexcept

  1437. {

  1438.     pData->osc.idle();

  1439. }

  1440. 

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

  1442. {

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

  1444. }

  1445. 

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

  1447. {

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

  1449. }

  1450. 

  1451. #ifdef BUILD_BRIDGE

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

  1453. {

  1454.     pData->oscData = oscData;

  1455. }

  1456. #endif

  1457. 

  1458. // -----------------------------------------------------------------------

  1459. // Helper functions

  1460. 

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

  1462. {

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

  1464. }

  1465. 

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

  1467. {

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

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

  1470. 

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

  1472. }

  1473. 

  1474. // -----------------------------------------------------------------------

  1475. // Internal stuff

  1476. 

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

  1478. {

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

  1480. 

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

  1482.     {

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

  1484. 

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

  1486.             plugin->bufferSizeChanged(newBufferSize);

  1487.     }

  1488. 

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

  1490. }

  1491. 

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

  1493. {

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

  1495. 

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

  1497.     {

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

  1499. 

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

  1501.             plugin->sampleRateChanged(newSampleRate);

  1502.     }

  1503. 

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

  1505. }

  1506. 

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

  1508. {

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

  1510. 

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

  1512.     {

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

  1514. 

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

  1516.             plugin->offlineModeChanged(isOfflineNow);

  1517.     }

  1518. }

  1519. 

  1520. void CarlaEngine::runPendingRtEvents() noexcept

  1521. {

  1522.     pData->doNextPluginAction(true);

  1523. 

  1524.     if (pData->time.playing)

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

  1526. 

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

  1528.     {

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

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

  1531.     }

  1532. }

  1533. 

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

  1535. {

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

  1537. 

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

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

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

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

  1542. }

  1543. 

  1544. // -----------------------------------------------------------------------

  1545. // Bridge/Controller OSC stuff

  1546. 

  1547. #ifdef BUILD_BRIDGE

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

  1549. {

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

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

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

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

  1554. 

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

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

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

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

  1559. }

  1560. 

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

  1562. {

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

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

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

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

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

  1568.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  1569.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  1571. 

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

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

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

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

  1576. }

  1577. 

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

  1579. {

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

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

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

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

  1584. 

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

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

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

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

  1589. }

  1590. 

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

  1592. {

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

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

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

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

  1597. 

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

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

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

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

  1602. }

  1603. 

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

  1605. {

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

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

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

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

  1610. 

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

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

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

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

  1615. }

  1616. 

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

  1618. {

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

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

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

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

  1623. 

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

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

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

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

  1628. }

  1629. 

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

  1631. {

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

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

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

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

  1636. 

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

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

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

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

  1641. }

  1642. 

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

  1644. {

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

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

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

  1648.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  1649.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  1651. 

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

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

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

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

  1656. }

  1657. 

  1658. void CarlaEngine::oscSend_bridge_parameter_ranges1(const uint32_t index, const float def, const float min, const float max) 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_debug("CarlaEngine::oscSend_bridge_parameter_ranges(%i, %f, %f, %f)", index, def, min, max);

  1664. 

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

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

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

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

  1669. }

  1670. 

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

  1672. {

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

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

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

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

  1677. 

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

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

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

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

  1682. }

  1683. 

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

  1685. {

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

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

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

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

  1690. 

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

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

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

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

  1695. }

  1696. 

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

  1698. {

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

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

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

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

  1703. 

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

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

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

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

  1708. }

  1709. 

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

  1711. {

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

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

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

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

  1716. 

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

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

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

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

  1721. }

  1722. 

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

  1724. {

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

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

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

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

  1729. 

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

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

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

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

  1734. }

  1735. 

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

  1737. {

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

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

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

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

  1742. 

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

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

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

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

  1747. }

  1748. 

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

  1750. {

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

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

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

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

  1755. 

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

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

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

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

  1760. }

  1761. 

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

  1763. {

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

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

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

  1767.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  1769. 

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

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

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

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

  1774. }

  1775. 

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

  1777. {

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

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

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

  1781.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  1783. 

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

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

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

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

  1788. }

  1789. 

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

  1791. {

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

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

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

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

  1796.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1798. 

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

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

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

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

  1803. }

  1804. 

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

  1806. {

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

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

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

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

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

  1812.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1814. 

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

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

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

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

  1819. }

  1820. 

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

  1822. {

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

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

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

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

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

  1828. 

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

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

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

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

  1833. }

  1834. 

  1835. void CarlaEngine::oscSend_bridge_pong() const noexcept

  1836. {

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

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

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

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

  1841. 

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

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

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

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

  1846. }

  1847. #else

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

  1849. {

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

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

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

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

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

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

  1856. 

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

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

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

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

  1861. }

  1862. 

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

  1864. {

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

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

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

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

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

  1870. 

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

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

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

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

  1875. }

  1876. 

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

  1878. {

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

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

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

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

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

  1884. 

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

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

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

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

  1889. }

  1890. 

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

  1892. {

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

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

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

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

  1897.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

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

  1899. 

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

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

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

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

  1904. }

  1905. 

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

  1907. {

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

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

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

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

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

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

  1914.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  1915.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  1917. 

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

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

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

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

  1922. }

  1923. 

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

  1925. {

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

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

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

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

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

  1931. 

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

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

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

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

  1936. }

  1937. 

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

  1939. {

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

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

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

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

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

  1945. 

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

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

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

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

  1950. }

  1951. 

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

  1953. {

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

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

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

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

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

  1959. 

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

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

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

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

  1964. }

  1965. 

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

  1967. {

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

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

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

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

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

  1973. 

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

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

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

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

  1978. }

  1979. 

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

  1981. {

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

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

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

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

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

  1987. 

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

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

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

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

  1992. }

  1993. 

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

  1995. {

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

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

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

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

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

  2001.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  2003. 

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

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

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

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

  2008. }

  2009. 

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

  2011. {

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

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

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

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

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

  2017.     CARLA_SAFE_ASSERT_RETURN(min < max,);

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

  2019. 

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

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

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

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

  2024. }

  2025. 

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

  2027. {

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

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

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

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

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

  2033.     CARLA_SAFE_ASSERT_RETURN(stepSmall <= stepLarge,);

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

  2035. 

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

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

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

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

  2040. }

  2041. 

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

  2043. {

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

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

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

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

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

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

  2050. 

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

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

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

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

  2055. }

  2056. 

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

  2058. {

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

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

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

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

  2063.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  2065. 

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

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

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

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

  2070. }

  2071. 

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

  2073. {

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

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

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

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

  2078.     CARLA_SAFE_ASSERT_RETURN(index != PARAMETER_NULL,);

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

  2080. 

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

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

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

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

  2085. }

  2086. 

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

  2088. {

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

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

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

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

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

  2094. 

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

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

  2097.     std::strcat(targetPath, "/set_default_value");

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

  2099. }

  2100. 

  2101. void CarlaEngine::oscSend_control_set_current_program(const uint pluginId, const int32_t index) const noexcept

  2102. {

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

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

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

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

  2107.     carla_debug("CarlaEngine::oscSend_control_set_current_program(%i, %i)", pluginId, index);

  2108. 

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

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

  2111.     std::strcat(targetPath, "/set_current_program");

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

  2113. }

  2114. 

  2115. void CarlaEngine::oscSend_control_set_current_midi_program(const uint pluginId, const int32_t index) const noexcept

  2116. {

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

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

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

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

  2121.     carla_debug("CarlaEngine::oscSend_control_set_current_midi_program(%i, %i)", pluginId, index);

  2122. 

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

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

  2125.     std::strcat(targetPath, "/set_current_midi_program");

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

  2127. }

  2128. 

  2129. void CarlaEngine::oscSend_control_set_program_name(const uint pluginId, const uint32_t index, const char* const name) const noexcept

  2130. {

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

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

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

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

  2135.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2136.     carla_debug("CarlaEngine::oscSend_control_set_program_name(%i, %i, \"%s\")", pluginId, index, name);

  2137. 

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

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

  2140.     std::strcat(targetPath, "/set_program_name");

  2141.     try_lo_send(pData->oscData->target, targetPath, "iis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), name);

  2142. }

  2143. 

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

  2145. {

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

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

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

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

  2150.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2151.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_data(%i, %i, %i, %i, \"%s\")", pluginId, index, bank, program, name);

  2152. 

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

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

  2155.     std::strcat(targetPath, "/set_midi_program_data");

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

  2157. }

  2158. 

  2159. void CarlaEngine::oscSend_control_note_on(const uint pluginId, const uint8_t channel, const uint8_t note, const uint8_t velo) const noexcept

  2160. {

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

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

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

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

  2165.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2166.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2167.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2168.     carla_debug("CarlaEngine::oscSend_control_note_on(%i, %i, %i, %i)", pluginId, channel, note, velo);

  2169. 

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

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

  2172.     std::strcat(targetPath, "/note_on");

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

  2174. }

  2175. 

  2176. void CarlaEngine::oscSend_control_note_off(const uint pluginId, const uint8_t channel, const uint8_t note) const noexcept

  2177. {

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

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

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

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

  2182.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2183.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2184.     carla_debug("CarlaEngine::oscSend_control_note_off(%i, %i, %i)", pluginId, channel, note);

  2185. 

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

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

  2188.     std::strcat(targetPath, "/note_off");

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

  2190. }

  2191. 

  2192. void CarlaEngine::oscSend_control_set_peaks(const uint pluginId) const noexcept

  2193. {

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

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

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

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

  2198. 

  2199.     // TODO - try and see if we can get peaks[4] ref

  2200.     const EnginePluginData& epData(pData->plugins[pluginId]);

  2201. 

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

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

  2204.     std::strcat(targetPath, "/set_peaks");

  2205.     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]);

  2206. }

  2207. 

  2208. void CarlaEngine::oscSend_control_exit() const noexcept

  2209. {

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

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

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

  2213.     carla_debug("CarlaEngine::oscSend_control_exit()");

  2214. 

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

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

  2217.     std::strcat(targetPath, "/exit");

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

  2219. }

  2220. #endif

  2221. 

  2222. // -----------------------------------------------------------------------

  2223. 

  2224. CARLA_BACKEND_END_NAMESPACE