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

1541 lines
48KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. /* TODO:

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

  20.  * - implement processPatchbay()

  21.  * - implement oscSend_control_switch_plugins()

  22.  * - proper find&load plugins

  23.  * - something about the peaks?

  24.  */

  25. 

  26. #include "CarlaEngineInternal.hpp"

  27. #include "CarlaPlugin.hpp"

  28. 

  29. #include "CarlaBackendUtils.hpp"

  30. #include "CarlaEngineUtils.hpp"

  31. #include "CarlaMathUtils.hpp"

  32. #include "CarlaStateUtils.hpp"

  33. #include "CarlaMIDI.h"

  34. 

  35. #include "jackbridge/JackBridge.hpp"

  36. #include "juce_core.h"

  37. 

  38. using juce::File;

  39. using juce::MemoryOutputStream;

  40. using juce::ScopedPointer;

  41. using juce::String;

  42. using juce::XmlDocument;

  43. using juce::XmlElement;

  44. 

  45. CARLA_BACKEND_START_NAMESPACE

  46. 

  47. // -----------------------------------------------------------------------

  48. // Carla Engine

  49. 

  50. CarlaEngine::CarlaEngine()

  51.     : pData(new ProtectedData(this))

  52. {

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

  54. }

  55. 

  56. CarlaEngine::~CarlaEngine()

  57. {

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

  59. 

  60.     delete pData;

  61. }

  62. 

  63. // -----------------------------------------------------------------------

  64. // Static calls

  65. 

  66. uint CarlaEngine::getDriverCount()

  67. {

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

  69. 

  70.     uint count = 0;

  71. 

  72.     if (jackbridge_is_ok())

  73.         count += 1;

  74. 

  75. #ifndef BUILD_BRIDGE

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

  77.     count += getJuceApiCount();

  78. # else

  79.     count += getRtAudioApiCount();

  80. # endif

  81. #endif

  82. 

  83.     return count;

  84. }

  85. 

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

  87. {

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

  89. 

  90.     uint index(index2);

  91. 

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

  93.         return "JACK";

  94. 

  95. #ifndef BUILD_BRIDGE

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

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

  98.     {

  99.         if (index < count)

  100.             return getJuceApiName(index);

  101.         index -= count;

  102.     }

  103. # else

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

  105.     {

  106.         if (index < count)

  107.             return getRtAudioApiName(index);

  108.         index -= count;

  109.     }

  110. # endif

  111. #endif

  112. 

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

  114.     return nullptr;

  115. }

  116. 

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

  118. {

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

  120. 

  121.     uint index(index2);

  122. 

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

  124.     {

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

  126.         return ret;

  127.     }

  128. 

  129. #ifndef BUILD_BRIDGE

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

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

  132.     {

  133.         if (index < count)

  134.             return getJuceApiDeviceNames(index);

  135.         index -= count;

  136.     }

  137. # else

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

  139.     {

  140.         if (index < count)

  141.             return getRtAudioApiDeviceNames(index);

  142.         index -= count;

  143.     }

  144. # endif

  145. #endif

  146. 

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

  148.     return nullptr;

  149. }

  150. 

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

  152. {

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

  154. 

  155.     uint index(index2);

  156. 

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

  158.     {

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

  160.         static EngineDriverDeviceInfo devInfo;

  161.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  162.         devInfo.bufferSizes = bufSizes;

  163.         devInfo.sampleRates = nullptr;

  164.         return &devInfo;

  165.     }

  166. 

  167. #ifndef BUILD_BRIDGE

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

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

  170.     {

  171.         if (index < count)

  172.             return getJuceDeviceInfo(index, deviceName);

  173.         index -= count;

  174.     }

  175. # else

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

  177.     {

  178.         if (index < count)

  179.             return getRtAudioDeviceInfo(index, deviceName);

  180.         index -= count;

  181.     }

  182. # endif

  183. #endif

  184. 

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

  186.     return nullptr;

  187. }

  188. 

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

  190. {

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

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

  193. 

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

  195.         return newJack();

  196. 

  197. #ifndef BUILD_BRIDGE

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

  199.     // -------------------------------------------------------------------

  200.     // macos

  201. 

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

  203.         return newJuce(AUDIO_API_CORE);

  204. 

  205.     // -------------------------------------------------------------------

  206.     // windows

  207. 

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

  209.         return newJuce(AUDIO_API_ASIO);

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

  211.         return newJuce(AUDIO_API_DS);

  212. #else

  213.     // -------------------------------------------------------------------

  214.     // common

  215. 

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

  217.         return newRtAudio(AUDIO_API_JACK);

  218. 

  219.     // -------------------------------------------------------------------

  220.     // linux

  221. 

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

  223.         return newRtAudio(AUDIO_API_ALSA);

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

  225.         return newRtAudio(AUDIO_API_OSS);

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

  227.         return newRtAudio(AUDIO_API_PULSE);

  228. # endif

  229. #endif

  230. 

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

  232.     return nullptr;

  233. }

  234. 

  235. // -----------------------------------------------------------------------

  236. // Constant values

  237. 

  238. uint CarlaEngine::getMaxClientNameSize() const noexcept

  239. {

  240.     return STR_MAX/2;

  241. }

  242. 

  243. uint CarlaEngine::getMaxPortNameSize() const noexcept

  244. {

  245.     return STR_MAX;

  246. }

  247. 

  248. uint CarlaEngine::getCurrentPluginCount() const noexcept

  249. {

  250.     return pData->curPluginCount;

  251. }

  252. 

  253. uint CarlaEngine::getMaxPluginNumber() const noexcept

  254. {

  255.     return pData->maxPluginNumber;

  256. }

  257. 

  258. // -----------------------------------------------------------------------

  259. // Virtual, per-engine type calls

  260. 

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

  262. {

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

  264. 

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

  266.         return false;

  267. 

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

  269.     return true;

  270. }

  271. 

  272. bool CarlaEngine::close()

  273. {

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

  275. 

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

  277.     {

  278.         pData->aboutToClose = true;

  279.         removeAllPlugins();

  280.     }

  281. 

  282. #ifndef BUILD_BRIDGE

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

  284.         oscSend_control_exit();

  285. #endif

  286. 

  287.     pData->close();

  288. 

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

  290.     return true;

  291. }

  292. 

  293. void CarlaEngine::idle() noexcept

  294. {

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

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

  297. 

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

  299.     {

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

  301. 

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

  303.         {

  304.             try {

  305.                 plugin->idle();

  306.             } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin idle");

  307.         }

  308.     }

  309. 

  310.     pData->osc.idle();

  311. }

  312. 

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

  314. {

  315.     return new CarlaEngineClient(*this);

  316. }

  317. 

  318. // -----------------------------------------------------------------------

  319. // Plugin management

  320. 

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

  322. {

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

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

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

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

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

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

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

  330. 

  331.     uint id;

  332. 

  333. #ifndef BUILD_BRIDGE

  334.     CarlaPlugin* oldPlugin = nullptr;

  335. 

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

  337.     {

  338.         id = pData->nextPluginId;

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

  340. 

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

  342. 

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

  344.     }

  345.     else

  346. #endif

  347.     {

  348.         id = pData->curPluginCount;

  349. 

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

  351.         {

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

  353.             return false;

  354.         }

  355. 

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

  357.     }

  358. 

  359.     CarlaPlugin::Initializer initializer = {

  360.         this,

  361.         id,

  362.         filename,

  363.         name,

  364.         label,

  365.         uniqueId

  366.     };

  367. 

  368.     CarlaPlugin* plugin = nullptr;

  369. 

  370. #ifndef BUILD_BRIDGE

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

  372. 

  373.     if (bridgeBinary.isNotEmpty())

  374.     {

  375. # ifndef CARLA_OS_WIN

  376.         if (btype == BINARY_NATIVE)

  377.         {

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

  379.         }

  380.         else

  381. # endif

  382.         {

  383.             switch (btype)

  384.             {

  385.             case BINARY_POSIX32:

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

  387.                 break;

  388.             case BINARY_POSIX64:

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

  390.                 break;

  391.             case BINARY_WIN32:

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

  393.                 break;

  394.             case BINARY_WIN64:

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

  396.                 break;

  397.             default:

  398.                 bridgeBinary.clear();

  399.                 break;

  400.             }

  401.         }

  402. 

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

  404.             bridgeBinary.clear();

  405.     }

  406. 

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

  408.     {

  409.         if (bridgeBinary.isNotEmpty())

  410.         {

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

  412.         }

  413. # ifdef CARLA_OS_LINUX

  414.         else if (btype == BINARY_WIN32)

  415.         {

  416.             // fallback to dssi-vst

  417.             File file(filename);

  418. 

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

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

  421. 

  422.             CarlaPlugin::Initializer init2 = {

  423.                 this,

  424.                 id,

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

  426.                 name,

  427.                 label2,

  428.                 uniqueId

  429.             };

  430. 

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

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

  433. 

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

  435. 

  436.             if (oldVstPath != nullptr)

  437.                 carla_setenv("VST_PATH", oldVstPath);

  438.         }

  439. # endif

  440.         else

  441.         {

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

  443.             return false;

  444.         }

  445.     }

  446.     else

  447. #endif // ! BUILD_BRIDGE

  448.     {

  449.         bool use16Outs;

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

  451. 

  452.         switch (ptype)

  453.         {

  454.         case PLUGIN_NONE:

  455.             break;

  456. 

  457.         case PLUGIN_INTERNAL:

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

  459.             {

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

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

  462.             }

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

  464.             {

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

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

  467.             }

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

  469.             {

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

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

  472.             }

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

  474.             {

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

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

  477.             }*/

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

  479.             break;

  480. 

  481.         case PLUGIN_LADSPA:

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

  483.             break;

  484. 

  485.         case PLUGIN_DSSI:

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

  487.             break;

  488. 

  489.         case PLUGIN_LV2:

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

  491.             break;

  492. 

  493.         case PLUGIN_VST:

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

  495.             break;

  496. 

  497.         case PLUGIN_VST3:

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

  499.             break;

  500. 

  501.         case PLUGIN_AU:

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

  503.             break;

  504. 

  505.         case PLUGIN_GIG:

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

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

  508.             break;

  509. 

  510.         case PLUGIN_SF2:

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

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

  513.             break;

  514. 

  515.         case PLUGIN_SFZ:

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

  517.             break;

  518.         }

  519.     }

  520. 

  521.     if (plugin == nullptr)

  522.         return false;

  523. 

  524.     plugin->registerToOscClient();

  525. 

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

  527.     pluginData.plugin      = plugin;

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

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

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

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

  532. 

  533. #ifndef BUILD_BRIDGE

  534.     if (oldPlugin != nullptr)

  535.     {

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

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

  538.         pData->thread.startThread();

  539. 

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

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

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

  543. 

  544.         delete oldPlugin;

  545. 

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

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

  548. 

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

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

  551. 

  552.         if (wasActive)

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

  554. 

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

  556.     }

  557.     else

  558. #endif

  559.     {

  560.         ++pData->curPluginCount;

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

  562.     }

  563. 

  564.     return true;

  565. }

  566. 

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

  568. {

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

  570. }

  571. 

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

  573. {

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

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

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

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

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

  579. 

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

  581. 

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

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

  584. 

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

  586. 

  587. #ifndef BUILD_BRIDGE

  588.     const ScopedActionLock sal(pData, kEnginePostActionRemovePlugin, id, 0, isRunning());

  589. 

  590.     if (isOscControlRegistered())

  591.         oscSend_control_remove_plugin(id);

  592. #else

  593.     pData->curPluginCount = 0;

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

  595. #endif

  596. 

  597.     delete plugin;

  598. 

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

  600.         pData->thread.startThread();

  601. 

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

  603.     return true;

  604. }

  605. 

  606. bool CarlaEngine::removeAllPlugins()

  607. {

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

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

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

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

  612. 

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

  614.         return true;

  615. 

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

  617. 

  618.     const ScopedActionLock sal(pData, kEnginePostActionZeroCount, 0, 0, isRunning());

  619. 

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

  621. 

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

  623.     {

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

  625. 

  626.         if (pluginData.plugin != nullptr)

  627.         {

  628.             delete pluginData.plugin;

  629.             pluginData.plugin = nullptr;

  630.         }

  631. 

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

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

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

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

  636. 

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

  638.     }

  639. 

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

  641.         pData->thread.startThread();

  642. 

  643.     return true;

  644. }

  645. 

  646. #ifndef BUILD_BRIDGE

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

  648. {

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

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

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

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

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

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

  655. 

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

  657. 

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

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

  660. 

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

  662.     {

  663.         plugin->setName(name);

  664.         return name;

  665.     }

  666. 

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

  668.     return nullptr;

  669. }

  670. 

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

  672. {

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

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

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

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

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

  678. 

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

  680. 

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

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

  683. 

  684.     char label[STR_MAX+1];

  685.     carla_zeroChar(label, STR_MAX+1);

  686.     plugin->getLabel(label);

  687. 

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

  689. 

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

  691.         return false;

  692. 

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

  694. 

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

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

  697. 

  698.     return true;

  699. }

  700. 

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

  702. {

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

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

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

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

  707. 

  708.     // might use this to reset

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

  710.     {

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

  712.         return true;

  713.     }

  714. 

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

  716. 

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

  718. 

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

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

  721. 

  722.     pData->nextPluginId = id;

  723. 

  724.     return true;

  725. }

  726. 

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

  728. {

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

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

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

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

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

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

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

  736. 

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

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

  739. 

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

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

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

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

  744. 

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

  746. 

  747.     const ScopedActionLock sal(pData, kEnginePostActionSwitchPlugins, idA, idB, isRunning());

  748. 

  749.     // TODO

  750.     //if (isOscControlRegistered())

  751.     //    oscSend_control_switch_plugins(idA, idB);

  752. 

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

  754.         pData->thread.startThread();

  755. 

  756.     return true;

  757. }

  758. #endif

  759. 

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

  761. {

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

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

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

  765. 

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

  767. }

  768. 

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

  770. {

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

  772. }

  773. 

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

  775. {

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

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

  778. 

  779.     CarlaString sname;

  780.     sname = name;

  781. 

  782.     if (sname.isEmpty())

  783.     {

  784.         sname = "(No name)";

  785.         return sname.dup();

  786.     }

  787. 

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

  789. 

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

  791.         return sname.dup();

  792. 

  793.     sname.truncate(maxNameSize);

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

  795. 

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

  797.     {

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

  799. 

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

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

  802.         {

  803.             if (sname != pluginName)

  804.                 continue;

  805.         }

  806. 

  807.         // Check if string has already been modified

  808.         {

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

  810. 

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

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

  813.             {

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

  815. 

  816.                 if (number == 9)

  817.                 {

  818.                     // next number is 10, 2 digits

  819.                     sname.truncate(len-4);

  820.                     sname += " (10)";

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

  822.                 }

  823.                 else

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

  825. 

  826.                 continue;

  827.             }

  828. 

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

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

  831.             {

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

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

  834. 

  835.                 if (n2 == '9')

  836.                 {

  837.                     n2 = '0';

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

  839.                 }

  840.                 else

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

  842. 

  843.                 sname[len-2] = n2;

  844.                 sname[len-3] = n3;

  845. 

  846.                 continue;

  847.             }

  848.         }

  849. 

  850.         // Modify string if not

  851.         sname += " (2)";

  852.     }

  853. 

  854.     return sname.dup();

  855. }

  856. 

  857. // -----------------------------------------------------------------------

  858. // Project management

  859. 

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

  861. {

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

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

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

  865. 

  866.     File file(filename);

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

  868. 

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

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

  871. 

  872.     // -------------------------------------------------------------------

  873. 

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

  875.         return loadProject(filename);

  876. 

  877.     // -------------------------------------------------------------------

  878. 

  879.     if (extension == "gig")

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

  881. 

  882.     if (extension == "sf2")

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

  884. 

  885.     if (extension == "sfz")

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

  887. 

  888.     // -------------------------------------------------------------------

  889. 

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

  891.     {

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

  893.         {

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

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

  896.             return true;

  897.         }

  898.         return false;

  899.     }

  900. 

  901.     // -------------------------------------------------------------------

  902. 

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

  904.     {

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

  906.         {

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

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

  909.             return true;

  910.         }

  911.         return false;

  912.     }

  913. 

  914.     // -------------------------------------------------------------------

  915.     // ZynAddSubFX

  916. 

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

  918.     {

  919. #ifdef WANT_ZYNADDSUBFX

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

  921.         {

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

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

  924.             return true;

  925.         }

  926.         return false;

  927. #else

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

  929.         return false;

  930. #endif

  931.     }

  932. 

  933.     // -------------------------------------------------------------------

  934. 

  935.     setLastError("Unknown file extension");

  936.     return false;

  937. }

  938. 

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

  940. {

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

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

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

  944. 

  945.     File file(filename);

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

  947. 

  948.     XmlDocument xml(file);

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

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

  951. 

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

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

  954. 

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

  956.     {

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

  958.         return false;

  959.     }

  960. 

  961.     // completely load file

  962.     xmlElement = xml.getDocumentElement(false);

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

  964. 

  965.     // handle plugins first

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

  967.     {

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

  969. 

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

  971.         {

  972.             StateSave stateSave;

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

  974. 

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

  976. 

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

  978. 

  979.             const void* extraStuff = nullptr;

  980. 

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

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

  983. 

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

  985. 

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

  987.             {

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

  989.                     extraStuff = "true";

  990.             }

  991. 

  992.             // TODO - proper find&load plugins

  993. 

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

  995.             {

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

  997.                     plugin->loadStateSave(stateSave);

  998.             }

  999.             else

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

  1001.         }

  1002. 

  1003.         if (isPreset)

  1004.             return true;

  1005.     }

  1006. 

  1007. #ifndef BUILD_BRIDGE

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

  1009. 

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

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

  1012.     {

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

  1014.             return true;

  1015.     }

  1016. 

  1017.     // now handle connections

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

  1019.     {

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

  1021. 

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

  1023.         {

  1024.             CarlaString sourcePort, targetPort;

  1025. 

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

  1027.             {

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

  1029. 

  1030.                 sourcePort.clear();

  1031.                 targetPort.clear();

  1032. 

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

  1034.                     continue;

  1035. 

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

  1037.                 {

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

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

  1040. 

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

  1042.                         sourcePort = text.toRawUTF8();

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

  1044.                         targetPort = text.toRawUTF8();

  1045.                 }

  1046. 

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

  1048.                     restorePatchbayConnection(sourcePort, targetPort);

  1049.             }

  1050.             break;

  1051.         }

  1052.     }

  1053. #endif

  1054. 

  1055.     return true;

  1056. }

  1057. 

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

  1059. {

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

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

  1062. 

  1063.     MemoryOutputStream out;

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

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

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

  1067. 

  1068.     bool firstPlugin = true;

  1069.     char strBuf[STR_MAX+1];

  1070. 

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

  1072.     {

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

  1074. 

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

  1076.         {

  1077.             if (! firstPlugin)

  1078.                 out << "\n";

  1079. 

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

  1081. 

  1082.             plugin->getRealName(strBuf);

  1083. 

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

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

  1086. 

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

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

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

  1090. 

  1091.             firstPlugin = false;

  1092.         }

  1093.     }

  1094. 

  1095. #ifndef BUILD_BRIDGE

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

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

  1098.     {

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

  1100.             return true;

  1101.     }

  1102. 

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

  1104.     {

  1105.         if (! firstPlugin)

  1106.             out << "\n";

  1107. 

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

  1109. 

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

  1111.         {

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

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

  1114. 

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

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

  1117. 

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

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

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

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

  1122. 

  1123.             delete[] connSource;

  1124.             delete[] connTarget;

  1125.         }

  1126. 

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

  1128.     }

  1129. #endif

  1130. 

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

  1132. 

  1133.     File file(filename);

  1134. 

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

  1136.         return true;

  1137. 

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

  1139.     return false;

  1140. }

  1141. 

  1142. // -----------------------------------------------------------------------

  1143. // Information (base)

  1144. 

  1145. uint CarlaEngine::getHints() const noexcept

  1146. {

  1147.     return pData->hints;

  1148. }

  1149. 

  1150. uint32_t CarlaEngine::getBufferSize() const noexcept

  1151. {

  1152.     return pData->bufferSize;

  1153. }

  1154. 

  1155. double CarlaEngine::getSampleRate() const noexcept

  1156. {

  1157.     return pData->sampleRate;

  1158. }

  1159. 

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

  1161. {

  1162.     return pData->name;

  1163. }

  1164. 

  1165. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1166. {

  1167.     return pData->options.processMode;

  1168. }

  1169. 

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

  1171. {

  1172.     return pData->options;

  1173. }

  1174. 

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

  1176. {

  1177.     return pData->timeInfo;

  1178. }

  1179. 

  1180. // -----------------------------------------------------------------------

  1181. // Information (peaks)

  1182. 

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

  1184. {

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

  1186. 

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

  1188. }

  1189. 

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

  1191. {

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

  1193. 

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

  1195. }

  1196. 

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

  1198. // Callback

  1199. 

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

  1201. {

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

  1203. 

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

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

  1206. 

  1207.     if (action == ENGINE_CALLBACK_IDLE)

  1208.         pData->isIdling = true;

  1209. 

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

  1211.     {

  1212.         try {

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

  1214.         } catch(...) {}

  1215.     }

  1216. 

  1217.     if (action == ENGINE_CALLBACK_IDLE)

  1218.         pData->isIdling = false;

  1219. }

  1220. 

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

  1222. {

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

  1224. 

  1225.     pData->callback    = func;

  1226.     pData->callbackPtr = ptr;

  1227. }

  1228. 

  1229. // -----------------------------------------------------------------------

  1230. // File Callback

  1231. 

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

  1233. {

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

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

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

  1237. 

  1238.     const char* ret = nullptr;

  1239. 

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

  1241.     {

  1242.         try {

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

  1244.         } catch(...) {}

  1245.     }

  1246. 

  1247.     return ret;

  1248. }

  1249. 

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

  1251. {

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

  1253. 

  1254.     pData->fileCallback    = func;

  1255.     pData->fileCallbackPtr = ptr;

  1256. }

  1257. 

  1258. // -----------------------------------------------------------------------

  1259. // Transport

  1260. 

  1261. void CarlaEngine::transportPlay() noexcept

  1262. {

  1263.     pData->time.playing = true;

  1264. }

  1265. 

  1266. void CarlaEngine::transportPause() noexcept

  1267. {

  1268.     pData->time.playing = false;

  1269. }

  1270. 

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

  1272. {

  1273.     pData->time.frame = frame;

  1274. }

  1275. 

  1276. // -----------------------------------------------------------------------

  1277. // Error handling

  1278. 

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

  1280. {

  1281.     return pData->lastError;

  1282. }

  1283. 

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

  1285. {

  1286.     pData->lastError = error;

  1287. }

  1288. 

  1289. void CarlaEngine::setAboutToClose() noexcept

  1290. {

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

  1292. 

  1293.     pData->aboutToClose = true;

  1294. }

  1295. 

  1296. // -----------------------------------------------------------------------

  1297. // Global options

  1298. 

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

  1300. {

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

  1302. 

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

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

  1305. 

  1306.     switch (option)

  1307.     {

  1308.     case ENGINE_OPTION_DEBUG:

  1309.     case ENGINE_OPTION_NSM_INIT:

  1310.         break;

  1311. 

  1312.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1315.         break;

  1316. 

  1317.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1320.         break;

  1321. 

  1322.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1325.         break;

  1326. 

  1327.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1330.         break;

  1331. 

  1332.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1335.         break;

  1336. 

  1337.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1340.         break;

  1341. 

  1342.     case ENGINE_OPTION_MAX_PARAMETERS:

  1343.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1345.         break;

  1346. 

  1347.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1348.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1350.         break;

  1351. 

  1352.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1355.         break;

  1356. 

  1357.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1358.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1360.         break;

  1361. 

  1362.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1363.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1365.         break;

  1366. 

  1367.     case ENGINE_OPTION_AUDIO_DEVICE:

  1368.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1369. 

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

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

  1372. 

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

  1374.         break;

  1375. 

  1376.     case ENGINE_OPTION_PATH_BINARIES:

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

  1378. 

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

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

  1381. 

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

  1383.         break;

  1384. 

  1385.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1387. 

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

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

  1390. 

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

  1392.         break;

  1393. 

  1394.     case ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1397.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1399.         break;

  1400.     }

  1401. }

  1402. 

  1403. // -----------------------------------------------------------------------

  1404. // OSC Stuff

  1405. 

  1406. #ifdef BUILD_BRIDGE

  1407. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1408. {

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

  1410. }

  1411. #else

  1412. bool CarlaEngine::isOscControlRegistered() const noexcept

  1413. {

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

  1415. }

  1416. #endif

  1417. 

  1418. void CarlaEngine::idleOsc() const noexcept

  1419. {

  1420.     pData->osc.idle();

  1421. }

  1422. 

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

  1424. {

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

  1426. }

  1427. 

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

  1429. {

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

  1431. }

  1432. 

  1433. #ifdef BUILD_BRIDGE

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

  1435. {

  1436.     pData->oscData = oscData;

  1437. }

  1438. #endif

  1439. 

  1440. // -----------------------------------------------------------------------

  1441. // Helper functions

  1442. 

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

  1444. {

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

  1446. }

  1447. 

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

  1449. {

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

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

  1452. 

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

  1454. }

  1455. 

  1456. // -----------------------------------------------------------------------

  1457. // Internal stuff

  1458. 

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

  1460. {

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

  1462. 

  1463. #ifndef BUILD_BRIDGE

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

  1465. #endif

  1466. 

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

  1468.     {

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

  1470. 

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

  1472.             plugin->bufferSizeChanged(newBufferSize);

  1473.     }

  1474. 

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

  1476. }

  1477. 

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

  1479. {

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

  1481. 

  1482. #ifndef BUILD_BRIDGE

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

  1484. #endif

  1485. 

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

  1487.     {

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

  1489. 

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

  1491.             plugin->sampleRateChanged(newSampleRate);

  1492.     }

  1493. 

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

  1495. }

  1496. 

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

  1498. {

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

  1500. 

  1501. #ifndef BUILD_BRIDGE

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

  1503. #endif

  1504. 

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

  1506.     {

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

  1508. 

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

  1510.             plugin->offlineModeChanged(isOfflineNow);

  1511.     }

  1512. }

  1513. 

  1514. void CarlaEngine::runPendingRtEvents() noexcept

  1515. {

  1516.     pData->doNextPluginAction(true);

  1517. 

  1518.     if (pData->time.playing)

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

  1520. 

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

  1522.     {

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

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

  1525.     }

  1526. }

  1527. 

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

  1529. {

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

  1531. 

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

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

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

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

  1536. }

  1537. 

  1538. // -----------------------------------------------------------------------

  1539. 

  1540. CARLA_BACKEND_END_NAMESPACE