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

2428 lines
81KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2018 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.  * - something about the peaks?

  23.  */

  24. 

  25. #include "CarlaEngineInternal.hpp"

  26. #include "CarlaPlugin.hpp"

  27. 

  28. #include "CarlaBackendUtils.hpp"

  29. #include "CarlaBinaryUtils.hpp"

  30. #include "CarlaEngineUtils.hpp"

  31. #include "CarlaMathUtils.hpp"

  32. #include "CarlaPipeUtils.hpp"

  33. #include "CarlaStateUtils.hpp"

  34. #include "CarlaMIDI.h"

  35. 

  36. #include "jackbridge/JackBridge.hpp"

  37. 

  38. #include "water/files/File.h"

  39. #include "water/streams/MemoryOutputStream.h"

  40. #include "water/xml/XmlDocument.h"

  41. #include "water/xml/XmlElement.h"

  42. 

  43. // FIXME Remove on 2.1 release

  44. #include "lv2/atom.h"

  45. 

  46. using water::Array;

  47. using water::CharPointer_UTF8;

  48. using water::File;

  49. using water::MemoryOutputStream;

  50. using water::String;

  51. using water::StringArray;

  52. using water::XmlDocument;

  53. using water::XmlElement;

  54. 

  55. CARLA_BACKEND_START_NAMESPACE

  56. 

  57. // -----------------------------------------------------------------------

  58. // Carla Engine

  59. 

  60. CarlaEngine::CarlaEngine()

  61.     : pData(new ProtectedData(this))

  62. {

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

  64. }

  65. 

  66. CarlaEngine::~CarlaEngine()

  67. {

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

  69. 

  70.     delete pData;

  71. }

  72. 

  73. // -----------------------------------------------------------------------

  74. // Static calls

  75. 

  76. uint CarlaEngine::getDriverCount()

  77. {

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

  79. 

  80.     uint count = 0;

  81. 

  82.     if (jackbridge_is_ok())

  83.         count += 1;

  84. 

  85. #ifndef BUILD_BRIDGE

  86.     count += getRtAudioApiCount();

  87. #endif

  88. 

  89.     return count;

  90. }

  91. 

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

  93. {

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

  95. 

  96.     uint index(index2);

  97. 

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

  99.         return "JACK";

  100. 

  101. #ifndef BUILD_BRIDGE

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

  103.     {

  104.         if (index < count)

  105.             return getRtAudioApiName(index);

  106.     }

  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 ON", "Auto-Connect OFF", nullptr };

  122.         return ret;

  123.     }

  124. 

  125. #ifndef BUILD_BRIDGE

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

  127.     {

  128.         if (index < count)

  129.             return getRtAudioApiDeviceNames(index);

  130.     }

  131. #endif

  132. 

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

  134.     return nullptr;

  135. }

  136. 

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

  138. {

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

  140. 

  141.     uint index(index2);

  142. 

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

  144.     {

  145.         static EngineDriverDeviceInfo devInfo;

  146.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  147.         devInfo.bufferSizes = nullptr;

  148.         devInfo.sampleRates = nullptr;

  149.         return &devInfo;

  150.     }

  151. 

  152. #ifndef BUILD_BRIDGE

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

  154.     {

  155.         if (index < count)

  156.             return getRtAudioDeviceInfo(index, deviceName);

  157.     }

  158. #endif

  159. 

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

  161.     return nullptr;

  162. }

  163. 

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

  165. {

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

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

  168. 

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

  170.         return newJack();

  171. 

  172. #ifndef BUILD_BRIDGE

  173.     // -------------------------------------------------------------------

  174.     // common

  175. 

  176.     if (std::strcmp(driverName, "Dummy") == 0)

  177.         return newRtAudio(AUDIO_API_NULL);

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

  179.         return newRtAudio(AUDIO_API_JACK);

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

  181.         return newRtAudio(AUDIO_API_OSS);

  182. 

  183.     // -------------------------------------------------------------------

  184.     // linux

  185. 

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

  187.         return newRtAudio(AUDIO_API_ALSA);

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

  189.         return newRtAudio(AUDIO_API_PULSEAUDIO);

  190. 

  191.     // -------------------------------------------------------------------

  192.     // macos

  193. 

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

  195.         return newRtAudio(AUDIO_API_COREAUDIO);

  196. 

  197.     // -------------------------------------------------------------------

  198.     // windows

  199. 

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

  201.         return newRtAudio(AUDIO_API_ASIO);

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

  203.         return newRtAudio(AUDIO_API_DIRECTSOUND);

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

  205.         return newRtAudio(AUDIO_API_WASAPI);

  206. #endif

  207. 

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

  209.     return nullptr;

  210. }

  211. 

  212. // -----------------------------------------------------------------------

  213. // Constant values

  214. 

  215. uint CarlaEngine::getMaxClientNameSize() const noexcept

  216. {

  217.     return STR_MAX/2;

  218. }

  219. 

  220. uint CarlaEngine::getMaxPortNameSize() const noexcept

  221. {

  222.     return STR_MAX;

  223. }

  224. 

  225. uint CarlaEngine::getCurrentPluginCount() const noexcept

  226. {

  227.     return pData->curPluginCount;

  228. }

  229. 

  230. uint CarlaEngine::getMaxPluginNumber() const noexcept

  231. {

  232.     return pData->maxPluginNumber;

  233. }

  234. 

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

  236. // Virtual, per-engine type calls

  237. 

  238. bool CarlaEngine::close()

  239. {

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

  241. 

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

  243.     {

  244.         pData->aboutToClose = true;

  245.         removeAllPlugins();

  246.     }

  247. 

  248. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

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

  250.         oscSend_control_exit();

  251. #endif

  252. 

  253.     pData->close();

  254. 

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

  256.     return true;

  257. }

  258. 

  259. bool CarlaEngine::usesConstantBufferSize() const noexcept

  260. {

  261.     return true;

  262. }

  263. 

  264. void CarlaEngine::idle() noexcept

  265. {

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

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

  268.     CARLA_SAFE_ASSERT_RETURN(getType() != kEngineTypePlugin,);

  269. 

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

  271.     {

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

  273. 

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

  275.         {

  276.             const uint hints(plugin->getHints());

  277. 

  278.             if ((hints & PLUGIN_HAS_CUSTOM_UI) != 0 && (hints & PLUGIN_NEEDS_UI_MAIN_THREAD) != 0)

  279.             {

  280.                 try {

  281.                     plugin->uiIdle();

  282.                 } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  283.             }

  284.         }

  285.     }

  286. 

  287. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  288.     pData->osc.idle();

  289. #endif

  290. }

  291. 

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

  293. {

  294.     return new CarlaEngineClient(*this);

  295. }

  296. 

  297. // -----------------------------------------------------------------------

  298. // Plugin management

  299. 

  300. bool CarlaEngine::addPlugin(const BinaryType btype, const PluginType ptype,

  301.                             const char* const filename, const char* const name, const char* const label, const int64_t uniqueId,

  302.                             const void* const extra, const uint options)

  303. {

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

  305. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  308. #endif

  309.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

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

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

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

  313.     carla_debug("CarlaEngine::addPlugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p, %u)", btype, BinaryType2Str(btype), ptype, PluginType2Str(ptype), filename, name, label, uniqueId, extra, options);

  314. 

  315.     uint id;

  316. 

  317. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  318.     CarlaPlugin* oldPlugin = nullptr;

  319. 

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

  321.     {

  322.         id = pData->nextPluginId;

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

  324. 

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

  326. 

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

  328.     }

  329.     else

  330. #endif

  331.     {

  332.         id = pData->curPluginCount;

  333. 

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

  335.         {

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

  337.             return false;

  338.         }

  339. 

  340. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  342. #endif

  343.     }

  344. 

  345.     CarlaPlugin::Initializer initializer = {

  346.         this,

  347.         id,

  348.         filename,

  349.         name,

  350.         label,

  351.         uniqueId,

  352.         options

  353.     };

  354. 

  355.     CarlaPlugin* plugin = nullptr;

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

  357. 

  358.     if (bridgeBinary.isNotEmpty())

  359.     {

  360. #ifndef CARLA_OS_WIN

  361.         if (btype == BINARY_NATIVE)

  362.         {

  363.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-native";

  364.         }

  365.         else

  366. #endif

  367.         {

  368.             switch (btype)

  369.             {

  370.             case BINARY_POSIX32:

  371.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-posix32";

  372.                 break;

  373.             case BINARY_POSIX64:

  374.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-posix64";

  375.                 break;

  376.             case BINARY_WIN32:

  377.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-win32.exe";

  378.                 break;

  379.             case BINARY_WIN64:

  380.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-win64.exe";

  381.                 break;

  382.             default:

  383.                 bridgeBinary.clear();

  384.                 break;

  385.             }

  386.         }

  387. 

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

  389.             bridgeBinary.clear();

  390.     }

  391. 

  392.     // Prefer bridges for some specific plugins

  393.     bool preferBridges = pData->options.preferPluginBridges;

  394. 

  395. #ifndef BUILD_BRIDGE

  396.     if (! preferBridges)

  397.     {

  398.         if (ptype == PLUGIN_LV2 && label != nullptr)

  399.         {

  400.             if (std::strncmp(label, "http://calf.sourceforge.net/plugins/", 36) == 0 ||

  401.                 std::strcmp(label, "http://factorial.hu/plugins/lv2/ir") == 0 ||

  402.                 std::strstr(label, "v1.sourceforge.net/lv2") != nullptr)

  403.             {

  404.                 preferBridges = true;

  405.             }

  406.         }

  407.     }

  408. #endif // ! BUILD_BRIDGE

  409. 

  410.     const bool canBeBridged = ptype != PLUGIN_INTERNAL

  411.                            && ptype != PLUGIN_SF2

  412.                            && ptype != PLUGIN_SFZ

  413.                            && ptype != PLUGIN_JACK;

  414. 

  415.     if (canBeBridged && (btype != BINARY_NATIVE || (preferBridges && bridgeBinary.isNotEmpty())))

  416.     {

  417.         if (bridgeBinary.isNotEmpty())

  418.         {

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

  420.         }

  421.         else

  422.         {

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

  424.             return false;

  425.         }

  426.     }

  427.     else

  428.     {

  429. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  430.         bool use16Outs;

  431. #endif

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

  433. 

  434.         switch (ptype)

  435.         {

  436.         case PLUGIN_NONE:

  437.             break;

  438. 

  439.         case PLUGIN_LADSPA:

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

  441.             break;

  442. 

  443.         case PLUGIN_DSSI:

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

  445.             break;

  446. 

  447.         case PLUGIN_LV2:

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

  449.             break;

  450. 

  451.         case PLUGIN_VST2:

  452.             plugin = CarlaPlugin::newVST2(initializer);

  453.             break;

  454. 

  455. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  456.         case PLUGIN_INTERNAL:

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

  458.             break;

  459. 

  460.         case PLUGIN_SF2:

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

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

  463.             break;

  464. 

  465.         case PLUGIN_SFZ:

  466.             plugin = CarlaPlugin::newSFZero(initializer);

  467.             break;

  468. 

  469.         case PLUGIN_JACK:

  470.             plugin = CarlaPlugin::newJackApp(initializer);

  471.             break;

  472. #else

  473.         case PLUGIN_INTERNAL:

  474.         case PLUGIN_SF2:

  475.         case PLUGIN_SFZ:

  476.         case PLUGIN_JACK:

  477.             setLastError("Plugin bridges cannot handle this binary");

  478.             break;

  479. #endif

  480.         }

  481.     }

  482. 

  483.     if (plugin == nullptr)

  484.         return false;

  485. 

  486.     plugin->reload();

  487. 

  488.     bool canRun = true;

  489. 

  490.     /**/ if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  491.     {

  492.         if (plugin->getCVInCount() > 0 || plugin->getCVInCount() > 0)

  493.         {

  494.             setLastError("Carla's rack mode cannot work with plugins that have CV ports, sorry!");

  495.             canRun = false;

  496.         }

  497.     }

  498.     else if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  499.     {

  500.         /**/ if (plugin->getMidiInCount() > 1 || plugin->getMidiOutCount() > 1)

  501.         {

  502.             setLastError("Carla's patchbay mode cannot work with plugins that have multiple MIDI ports, sorry!");

  503.             canRun = false;

  504.         }

  505.         else if (plugin->getCVInCount() > 0 || plugin->getCVInCount() > 0)

  506.         {

  507.             setLastError("CV ports in patchbay mode is still TODO");

  508.             canRun = false;

  509.         }

  510.     }

  511. 

  512.     if (! canRun)

  513.     {

  514.         delete plugin;

  515.         return false;

  516.     }

  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_ALTERNATIVE_ARCH

  526.     if (oldPlugin != nullptr)

  527.     {

  528.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  529. 

  530.         const ScopedThreadStopper sts(this);

  531. 

  532.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  533.             pData->graph.replacePlugin(oldPlugin, plugin);

  534. 

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

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

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

  538. 

  539.         delete oldPlugin;

  540. 

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

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

  543. 

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

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

  546. 

  547.         plugin->setActive(wasActive, true, true);

  548.         plugin->setEnabled(true);

  549. 

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

  551.     }

  552.     else if (! pData->loadingProject)

  553. #endif

  554.     {

  555.         plugin->setEnabled(true);

  556. 

  557.         ++pData->curPluginCount;

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

  559. 

  560.         if (getType() != kEngineTypeBridge)

  561.             plugin->setActive(true, false, true);

  562. 

  563. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  564.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  565.             pData->graph.addPlugin(plugin);

  566. #endif

  567.     }

  568. 

  569. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  570.     plugin->registerToOscClient();

  571. #endif

  572. 

  573.     return true;

  574. }

  575. 

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

  577. {

  578.     return addPlugin(BINARY_NATIVE, ptype, filename, name, label, uniqueId, extra, 0x0);

  579. }

  580. 

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

  582. {

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

  584. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  587. #endif

  588.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

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

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

  591. 

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

  593. 

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

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

  596. 

  597.     const ScopedThreadStopper sts(this);

  598. 

  599. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  600.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  601.         pData->graph.removePlugin(plugin);

  602. 

  603.     const ScopedActionLock sal(this, kEnginePostActionRemovePlugin, id, 0);

  604. 

  605.     /*

  606.     for (uint i=id; i < pData->curPluginCount; ++i)

  607.     {

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

  609.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  610.         plugin2->updateOscURL();

  611.     }

  612.     */

  613. 

  614. # if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  615.     if (isOscControlRegistered())

  616.         oscSend_control_remove_plugin(id);

  617. # endif

  618. #else

  619.     pData->curPluginCount = 0;

  620.     carla_zeroStructs(pData->plugins, 1);

  621. #endif

  622. 

  623.     delete plugin;

  624. 

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

  626.     return true;

  627. }

  628. 

  629. bool CarlaEngine::removeAllPlugins()

  630. {

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

  632. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  635. #endif

  636.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

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

  638. 

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

  640.         return true;

  641. 

  642.     const ScopedThreadStopper sts(this);

  643. 

  644.     const uint curPluginCount(pData->curPluginCount);

  645. 

  646. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  647.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  648.         pData->graph.removeAllPlugins();

  649. 

  650. # if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  651.     if (isOscControlRegistered())

  652.     {

  653.         for (uint i=0; i < curPluginCount; ++i)

  654.             oscSend_control_remove_plugin(curPluginCount-i-1);

  655.     }

  656. # endif

  657. #endif

  658. 

  659.     const ScopedActionLock sal(this, kEnginePostActionZeroCount, 0, 0);

  660. 

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

  662. 

  663.     for (uint i=0; i < curPluginCount; ++i)

  664.     {

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

  666. 

  667.         if (pluginData.plugin != nullptr)

  668.         {

  669.             delete pluginData.plugin;

  670.             pluginData.plugin = nullptr;

  671.         }

  672. 

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

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

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

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

  677. 

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

  679.     }

  680. 

  681.     return true;

  682. }

  683. 

  684. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  686. {

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

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

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

  690.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

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

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

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

  694. 

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

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

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

  698. 

  699.     const char* const uniqueName(getUniquePluginName(newName));

  700.     CARLA_SAFE_ASSERT_RETURN_ERRN(uniqueName != nullptr, "Unable to get new unique plugin name");

  701. 

  702.     plugin->setName(uniqueName);

  703. 

  704.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  705.         pData->graph.renamePlugin(plugin, uniqueName);

  706. 

  707.     delete[] uniqueName;

  708.     return plugin->getName();

  709. }

  710. 

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

  712. {

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

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

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

  716.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

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

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

  719. 

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

  721. 

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

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

  724. 

  725.     char label[STR_MAX+1];

  726.     carla_zeroChars(label, STR_MAX+1);

  727.     plugin->getLabel(label);

  728. 

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

  730. 

  731.     if (! addPlugin(plugin->getBinaryType(), plugin->getType(),

  732.                     plugin->getFilename(), plugin->getName(), label, plugin->getUniqueId(),

  733.                     plugin->getExtraStuff(), plugin->getOptionsEnabled()))

  734.         return false;

  735. 

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

  737. 

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

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

  740. 

  741.     return true;

  742. }

  743. 

  744. bool CarlaEngine::replacePlugin(const uint id) noexcept

  745. {

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

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

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

  749.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

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

  751. 

  752.     // might use this to reset

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

  754.     {

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

  756.         return true;

  757.     }

  758. 

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

  760. 

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

  762. 

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

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

  765. 

  766.     pData->nextPluginId = id;

  767. 

  768.     return true;

  769. }

  770. 

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

  772. {

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

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

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

  776.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

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

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

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

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

  781. 

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

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

  784. 

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

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

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

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

  789. 

  790.     const ScopedThreadStopper sts(this);

  791. 

  792.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  793.         pData->graph.replacePlugin(pluginA, pluginB);

  794. 

  795.     const ScopedActionLock sal(this, kEnginePostActionSwitchPlugins, idA, idB);

  796. 

  797.     // TODO

  798.     /*

  799.     pluginA->updateOscURL();

  800.     pluginB->updateOscURL();

  801. 

  802.     if (isOscControlRegistered())

  803.         oscSend_control_switch_plugins(idA, idB);

  804.     */

  805. 

  806.     return true;

  807. }

  808. #endif

  809. 

  810. CarlaPlugin* CarlaEngine::getPlugin(const uint id) const noexcept

  811. {

  812. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  815. #endif

  816.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

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

  818. 

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

  820. }

  821. 

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

  823. {

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

  825. }

  826. 

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

  828. {

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

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

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

  832. 

  833.     CarlaString sname;

  834.     sname = name;

  835. 

  836.     if (sname.isEmpty())

  837.     {

  838.         sname = "(No name)";

  839.         return sname.dup();

  840.     }

  841. 

  842.     const std::size_t maxNameSize(carla_minConstrained<uint>(getMaxClientNameSize(), 0xff, 6U) - 6); // 6 = strlen(" (10)") + 1

  843. 

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

  845.         return sname.dup();

  846. 

  847.     sname.truncate(maxNameSize);

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

  849. 

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

  851.     {

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

  853. 

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

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

  856.         {

  857.             if (sname != pluginName)

  858.                 continue;

  859.         }

  860. 

  861.         // Check if string has already been modified

  862.         {

  863.             const std::size_t len(sname.length());

  864. 

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

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

  867.             {

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

  869. 

  870.                 if (number == 9)

  871.                 {

  872.                     // next number is 10, 2 digits

  873.                     sname.truncate(len-4);

  874.                     sname += " (10)";

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

  876.                 }

  877.                 else

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

  879. 

  880.                 continue;

  881.             }

  882. 

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

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

  885.             {

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

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

  888. 

  889.                 if (n2 == '9')

  890.                 {

  891.                     n2 = '0';

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

  893.                 }

  894.                 else

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

  896. 

  897.                 sname[len-2] = n2;

  898.                 sname[len-3] = n3;

  899. 

  900.                 continue;

  901.             }

  902.         }

  903. 

  904.         // Modify string if not

  905.         sname += " (2)";

  906.     }

  907. 

  908.     return sname.dup();

  909. }

  910. 

  911. // -----------------------------------------------------------------------

  912. // Project management

  913. 

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

  915. {

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

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

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

  919. 

  920.     const String jfilename = String(CharPointer_UTF8(filename));

  921.     File file(jfilename);

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

  923. 

  924.     CarlaString baseName(file.getFileNameWithoutExtension().toRawUTF8());

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

  926. 

  927.     const uint curPluginId(pData->nextPluginId < pData->curPluginCount ? pData->nextPluginId : pData->curPluginCount);

  928. 

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

  930.     // NOTE: please keep in sync with carla_get_supported_file_extensions!!

  931. 

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

  933.         return loadProject(filename);

  934. 

  935.     // -------------------------------------------------------------------

  936. 

  937.     if (extension == "sf2" || extension == "sf3")

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

  939. 

  940.     if (extension == "sfz")

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

  942. 

  943.     // -------------------------------------------------------------------

  944. 

  945.     if (

  946. #ifdef HAVE_SNDFILE

  947.         extension == "aif"  ||

  948.         extension == "aifc" ||

  949.         extension == "aiff" ||

  950.         extension == "au"   ||

  951.         extension == "bwf"  ||

  952.         extension == "flac" ||

  953.         extension == "htk"  ||

  954.         extension == "iff"  ||

  955.         extension == "mat4" ||

  956.         extension == "mat5" ||

  957.         extension == "oga"  ||

  958.         extension == "ogg"  ||

  959.         extension == "paf"  ||

  960.         extension == "pvf"  ||

  961.         extension == "pvf5" ||

  962.         extension == "sd2"  ||

  963.         extension == "sf"   ||

  964.         extension == "snd"  ||

  965.         extension == "svx"  ||

  966.         extension == "vcc"  ||

  967.         extension == "w64"  ||

  968.         extension == "wav"  ||

  969.         extension == "xi"   ||

  970. #endif

  971. #ifdef HAVE_FFMPEG

  972.         extension == "3g2" ||

  973.         extension == "3gp" ||

  974.         extension == "aac" ||

  975.         extension == "ac3" ||

  976.         extension == "amr" ||

  977.         extension == "ape" ||

  978.         extension == "mp2" ||

  979.         extension == "mp3" ||

  980.         extension == "mpc" ||

  981.         extension == "wma" ||

  982. # ifdef HAVE_SNDFILE

  983.         // FFmpeg without sndfile

  984.         extension == "flac" ||

  985.         extension == "oga"  ||

  986.         extension == "ogg"  ||

  987.         extension == "w64"  ||

  988.         extension == "wav"  ||

  989. # endif

  990. #endif

  991.         false

  992.        )

  993.     {

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

  995.         {

  996.             if (CarlaPlugin* const plugin = getPlugin(curPluginId))

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

  998.             return true;

  999.         }

  1000.         return false;

  1001.     }

  1002. 

  1003.     // -------------------------------------------------------------------

  1004. 

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

  1006.     {

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

  1008.         {

  1009.             if (CarlaPlugin* const plugin = getPlugin(curPluginId))

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

  1011.             return true;

  1012.         }

  1013.         return false;

  1014.     }

  1015. 

  1016.     // -------------------------------------------------------------------

  1017.     // ZynAddSubFX

  1018. 

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

  1020.     {

  1021. #ifdef HAVE_ZYN_DEPS

  1022.         CarlaString nicerName("Zyn - ");

  1023. 

  1024.         const std::size_t sep(baseName.find('-')+1);

  1025. 

  1026.         if (sep < baseName.length())

  1027.             nicerName += baseName.buffer()+sep;

  1028.         else

  1029.             nicerName += baseName;

  1030. 

  1031.         //nicerName

  1032.         if (addPlugin(PLUGIN_INTERNAL, nullptr, nicerName, "zynaddsubfx", 0, nullptr))

  1033.         {

  1034.             callback(ENGINE_CALLBACK_UI_STATE_CHANGED, curPluginId, 0, 0, 0.0f, nullptr);

  1035. 

  1036.             if (CarlaPlugin* const plugin = getPlugin(curPluginId))

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

  1038.             return true;

  1039.         }

  1040.         return false;

  1041. #else

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

  1043.         return false;

  1044. #endif

  1045.     }

  1046. 

  1047.     // -------------------------------------------------------------------

  1048.     // Direct plugin binaries

  1049. 

  1050. #ifdef CARLA_OS_MAC

  1051.     if (extension == "vst")

  1052.         return addPlugin(PLUGIN_VST2, filename, nullptr, nullptr, 0, nullptr);

  1053. #else

  1054.     if (extension == "dll" || extension == "so")

  1055.         return addPlugin(getBinaryTypeFromFile(filename), PLUGIN_VST2, filename, nullptr, nullptr, 0, nullptr, 0x0);

  1056. #endif

  1057. 

  1058.     // -------------------------------------------------------------------

  1059. 

  1060.     setLastError("Unknown file extension");

  1061.     return false;

  1062. }

  1063. 

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

  1065. {

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

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

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

  1069. 

  1070.     const String jfilename = String(CharPointer_UTF8(filename));

  1071.     File file(jfilename);

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

  1073. 

  1074.     XmlDocument xml(file);

  1075.     return loadProjectInternal(xml);

  1076. }

  1077. 

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

  1079. {

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

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

  1082. 

  1083.     MemoryOutputStream out;

  1084.     saveProjectInternal(out);

  1085. 

  1086.     const String jfilename = String(CharPointer_UTF8(filename));

  1087.     File file(jfilename);

  1088. 

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

  1090.         return true;

  1091. 

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

  1093.     return false;

  1094. }

  1095. 

  1096. // -----------------------------------------------------------------------

  1097. // Information (base)

  1098. 

  1099. uint CarlaEngine::getHints() const noexcept

  1100. {

  1101.     return pData->hints;

  1102. }

  1103. 

  1104. uint32_t CarlaEngine::getBufferSize() const noexcept

  1105. {

  1106.     return pData->bufferSize;

  1107. }

  1108. 

  1109. double CarlaEngine::getSampleRate() const noexcept

  1110. {

  1111.     return pData->sampleRate;

  1112. }

  1113. 

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

  1115. {

  1116.     return pData->name;

  1117. }

  1118. 

  1119. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1120. {

  1121.     return pData->options.processMode;

  1122. }

  1123. 

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

  1125. {

  1126.     return pData->options;

  1127. }

  1128. 

  1129. EngineTimeInfo CarlaEngine::getTimeInfo() const noexcept

  1130. {

  1131.     return pData->timeInfo;

  1132. }

  1133. 

  1134. // -----------------------------------------------------------------------

  1135. // Information (peaks)

  1136. 

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

  1138. {

  1139.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1140.     {

  1141.         // get peak from first plugin, if available

  1142.         if (pData->curPluginCount > 0)

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

  1144.         return 0.0f;

  1145.     }

  1146. 

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

  1148. 

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

  1150. }

  1151. 

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

  1153. {

  1154.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1155.     {

  1156.         // get peak from last plugin, if available

  1157.         if (pData->curPluginCount > 0)

  1158.             return pData->plugins[pData->curPluginCount-1].outsPeak[isLeft ? 0 : 1];

  1159.         return 0.0f;

  1160.     }

  1161. 

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

  1163. 

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

  1165. }

  1166. 

  1167. // -----------------------------------------------------------------------

  1168. // Callback

  1169. 

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

  1171. {

  1172. #ifdef DEBUG

  1173.     if (action != ENGINE_CALLBACK_IDLE && action != ENGINE_CALLBACK_NOTE_ON && action != ENGINE_CALLBACK_NOTE_OFF)

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

  1175. #endif

  1176. 

  1177. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1178.     if (pData->isIdling)

  1179. #else

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

  1181. #endif

  1182.     {

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

  1184.     }

  1185. 

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

  1187.     {

  1188.         if (action == ENGINE_CALLBACK_IDLE)

  1189.             ++pData->isIdling;

  1190. 

  1191.         try {

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

  1193. #if defined(CARLA_OS_LINUX) && defined(__arm__)

  1194.         } catch (__cxxabiv1::__forced_unwind&) {

  1195.             carla_stderr2("Caught forced unwind exception in callback");

  1196.             throw;

  1197. #endif

  1198.         } catch (...) {

  1199.             carla_safe_exception("callback", __FILE__, __LINE__);

  1200.         }

  1201. 

  1202.         if (action == ENGINE_CALLBACK_IDLE)

  1203.             --pData->isIdling;

  1204.     }

  1205. }

  1206. 

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

  1208. {

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

  1210. 

  1211.     pData->callback    = func;

  1212.     pData->callbackPtr = ptr;

  1213. }

  1214. 

  1215. // -----------------------------------------------------------------------

  1216. // File Callback

  1217. 

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

  1219. {

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

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

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

  1223. 

  1224.     const char* ret = nullptr;

  1225. 

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

  1227.     {

  1228.         try {

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

  1230.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1231.     }

  1232. 

  1233.     return ret;

  1234. }

  1235. 

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

  1237. {

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

  1239. 

  1240.     pData->fileCallback    = func;

  1241.     pData->fileCallbackPtr = ptr;

  1242. }

  1243. 

  1244. // -----------------------------------------------------------------------

  1245. // Transport

  1246. 

  1247. void CarlaEngine::transportPlay() noexcept

  1248. {

  1249.     pData->timeInfo.playing = true;

  1250.     pData->time.setNeedsReset();

  1251. }

  1252. 

  1253. void CarlaEngine::transportPause() noexcept

  1254. {

  1255.     if (pData->timeInfo.playing)

  1256.         pData->time.pause();

  1257.     else

  1258.         pData->time.setNeedsReset();

  1259. }

  1260. 

  1261. void CarlaEngine::transportBPM(const double bpm) noexcept

  1262. {

  1263.     try {

  1264.         pData->time.setBPM(bpm);

  1265.     } CARLA_SAFE_EXCEPTION("CarlaEngine::transportBPM");

  1266. }

  1267. 

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

  1269. {

  1270.     pData->time.relocate(frame);

  1271. }

  1272. 

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

  1274. // Error handling

  1275. 

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

  1277. {

  1278.     return pData->lastError;

  1279. }

  1280. 

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

  1282. {

  1283.     pData->lastError = error;

  1284. }

  1285. 

  1286. // -----------------------------------------------------------------------

  1287. // Misc

  1288. 

  1289. bool CarlaEngine::isAboutToClose() const noexcept

  1290. {

  1291.     return pData->aboutToClose;

  1292. }

  1293. 

  1294. bool CarlaEngine::setAboutToClose() noexcept

  1295. {

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

  1297. 

  1298.     pData->aboutToClose = true;

  1299. 

  1300.     return (pData->isIdling == 0);

  1301. }

  1302. 

  1303. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1304. bool CarlaEngine::isLoadingProject() const noexcept

  1305. {

  1306.     return pData->loadingProject;

  1307. }

  1308. #endif

  1309. 

  1310. // -----------------------------------------------------------------------

  1311. // Global options

  1312. 

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

  1314. {

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

  1316. 

  1317.     if (isRunning())

  1318.     {

  1319.         switch (option)

  1320.         {

  1321.         case ENGINE_OPTION_PROCESS_MODE:

  1322.         case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

  1323.         case ENGINE_OPTION_AUDIO_DEVICE:

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

  1325.                                 option, EngineOption2Str(option), value, valueStr);

  1326.         default:

  1327.             break;

  1328.         }

  1329.     }

  1330. 

  1331.     // do not un-force stereo for rack mode

  1332.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK && option == ENGINE_OPTION_FORCE_STEREO && value != 0)

  1333.         return;

  1334. 

  1335.     switch (option)

  1336.     {

  1337.     case ENGINE_OPTION_DEBUG:

  1338.         break;

  1339. 

  1340.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1343.         break;

  1344. 

  1345.     case ENGINE_OPTION_TRANSPORT_MODE:

  1346.         CARLA_SAFE_ASSERT_RETURN(value >= ENGINE_TRANSPORT_MODE_DISABLED && value <= ENGINE_TRANSPORT_MODE_BRIDGE,);

  1347.         CARLA_SAFE_ASSERT_RETURN(getType() == kEngineTypeJack || value != ENGINE_TRANSPORT_MODE_JACK,);

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

  1349.         delete[] pData->options.transportExtra;

  1350.         if (value >= ENGINE_TRANSPORT_MODE_DISABLED && valueStr != nullptr)

  1351.             pData->options.transportExtra = carla_strdup_safe(valueStr);

  1352.         else

  1353.             pData->options.transportExtra = nullptr;

  1354. 

  1355.         pData->time.setNeedsReset();

  1356. 

  1357. #if defined(HAVE_HYLIA) && !defined(BUILD_BRIDGE)

  1358.         // enable link now if needed

  1359.         {

  1360.             const bool linkEnabled = pData->options.transportExtra != nullptr && std::strstr(pData->options.transportExtra, ":link:") != nullptr;

  1361.             pData->time.enableLink(linkEnabled);

  1362.         }

  1363. #endif

  1364.         break;

  1365. 

  1366.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1369.         break;

  1370. 

  1371.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1372. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1373.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1374. #else

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

  1376. #endif

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

  1378.         break;

  1379. 

  1380.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1383.         break;

  1384. 

  1385.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1388.         break;

  1389. 

  1390.     case ENGINE_OPTION_MAX_PARAMETERS:

  1391.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1393.         break;

  1394. 

  1395.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1396.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1398.         break;

  1399. 

  1400.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1401.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1403.         break;

  1404. 

  1405.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1406.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1408.         break;

  1409. 

  1410.     case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

  1412.         pData->options.audioTripleBuffer = (value != 0);

  1413.         break;

  1414. 

  1415.     case ENGINE_OPTION_AUDIO_DEVICE:

  1416.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1417. 

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

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

  1420. 

  1421.         pData->options.audioDevice = carla_strdup_safe(valueStr);

  1422.         break;

  1423. 

  1424.     case ENGINE_OPTION_PLUGIN_PATH:

  1425.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1426.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1427. 

  1428.         switch (value)

  1429.         {

  1430.         case PLUGIN_LADSPA:

  1431.             if (pData->options.pathLADSPA != nullptr)

  1432.                 delete[] pData->options.pathLADSPA;

  1433.             if (valueStr != nullptr)

  1434.                 pData->options.pathLADSPA = carla_strdup_safe(valueStr);

  1435.             else

  1436.                 pData->options.pathLADSPA = nullptr;

  1437.             break;

  1438.         case PLUGIN_DSSI:

  1439.             if (pData->options.pathDSSI != nullptr)

  1440.                 delete[] pData->options.pathDSSI;

  1441.             if (valueStr != nullptr)

  1442.                 pData->options.pathDSSI = carla_strdup_safe(valueStr);

  1443.             else

  1444.                 pData->options.pathDSSI = nullptr;

  1445.             break;

  1446.         case PLUGIN_LV2:

  1447.             if (pData->options.pathLV2 != nullptr)

  1448.                 delete[] pData->options.pathLV2;

  1449.             if (valueStr != nullptr)

  1450.                 pData->options.pathLV2 = carla_strdup_safe(valueStr);

  1451.             else

  1452.                 pData->options.pathLV2 = nullptr;

  1453.             break;

  1454.         case PLUGIN_VST2:

  1455.             if (pData->options.pathVST2 != nullptr)

  1456.                 delete[] pData->options.pathVST2;

  1457.             if (valueStr != nullptr)

  1458.                 pData->options.pathVST2 = carla_strdup_safe(valueStr);

  1459.             else

  1460.                 pData->options.pathVST2 = nullptr;

  1461.             break;

  1462.         case PLUGIN_SF2:

  1463.             if (pData->options.pathSF2 != nullptr)

  1464.                 delete[] pData->options.pathSF2;

  1465.             if (valueStr != nullptr)

  1466.                 pData->options.pathSF2 = carla_strdup_safe(valueStr);

  1467.             else

  1468.                 pData->options.pathSF2 = nullptr;

  1469.             break;

  1470.         case PLUGIN_SFZ:

  1471.             if (pData->options.pathSFZ != nullptr)

  1472.                 delete[] pData->options.pathSFZ;

  1473.             if (valueStr != nullptr)

  1474.                 pData->options.pathSFZ = carla_strdup_safe(valueStr);

  1475.             else

  1476.                 pData->options.pathSFZ = nullptr;

  1477.             break;

  1478.         default:

  1479.             return carla_stderr("CarlaEngine::setOption(%i:%s, %i, \"%s\") - Invalid plugin type", option, EngineOption2Str(option), value, valueStr);

  1480.             break;

  1481.         }

  1482.         break;

  1483. 

  1484.     case ENGINE_OPTION_PATH_BINARIES:

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

  1486. 

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

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

  1489. 

  1490.         pData->options.binaryDir = carla_strdup_safe(valueStr);

  1491.         break;

  1492. 

  1493.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1495. 

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

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

  1498. 

  1499.         pData->options.resourceDir = carla_strdup_safe(valueStr);

  1500.         break;

  1501. 

  1502.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR: {

  1503.         CARLA_SAFE_ASSERT_RETURN(pData->options.binaryDir != nullptr && pData->options.binaryDir[0] != '\0',);

  1504. 

  1505. #ifdef CARLA_OS_LINUX

  1506.         const ScopedEngineEnvironmentLocker _seel(this);

  1507. 

  1508.         if (value != 0)

  1509.         {

  1510.             CarlaString interposerPath(CarlaString(pData->options.binaryDir) + "/libcarla_interposer-safe.so");

  1511.             ::setenv("LD_PRELOAD", interposerPath.buffer(), 1);

  1512.         }

  1513.         else

  1514.         {

  1515.             ::unsetenv("LD_PRELOAD");

  1516.         }

  1517. #endif

  1518.     }   break;

  1519. 

  1520.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  1523.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1525.     }   break;

  1526. 

  1527. #if !defined(BUILD_BRIDGE_ALTERNATIVE_ARCH) && !defined(CARLA_OS_WIN)

  1528.     case ENGINE_OPTION_WINE_EXECUTABLE:

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

  1530. 

  1531.         if (pData->options.wine.executable != nullptr)

  1532.             delete[] pData->options.wine.executable;

  1533. 

  1534.         pData->options.wine.executable = carla_strdup_safe(valueStr);

  1535.         break;

  1536. 

  1537.     case ENGINE_OPTION_WINE_AUTO_PREFIX:

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

  1539.         pData->options.wine.autoPrefix = (value != 0);

  1540.         break;

  1541. 

  1542.     case ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  1544. 

  1545.         if (pData->options.wine.fallbackPrefix != nullptr)

  1546.             delete[] pData->options.wine.fallbackPrefix;

  1547. 

  1548.         pData->options.wine.fallbackPrefix = carla_strdup_safe(valueStr);

  1549.         break;

  1550. 

  1551.     case ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

  1553.         pData->options.wine.rtPrio = (value != 0);

  1554.         break;

  1555. 

  1556.     case ENGINE_OPTION_WINE_BASE_RT_PRIO:

  1557.         CARLA_SAFE_ASSERT_RETURN(value >= 1 && value <= 89,);

  1558.         pData->options.wine.baseRtPrio = value;

  1559.         break;

  1560. 

  1561.     case ENGINE_OPTION_WINE_SERVER_RT_PRIO:

  1562.         CARLA_SAFE_ASSERT_RETURN(value >= 1 && value <= 99,);

  1563.         pData->options.wine.serverRtPrio = value;

  1564.         break;

  1565. #endif

  1566. 

  1567.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  1568.         break;

  1569.     }

  1570. }

  1571. 

  1572. #ifndef BUILD_BRIDGE

  1573. // -----------------------------------------------------------------------

  1574. // OSC Stuff

  1575. 

  1576. bool CarlaEngine::isOscControlRegistered() const noexcept

  1577. {

  1578. # ifdef HAVE_LIBLO

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

  1580. # else

  1581.     return false;

  1582. # endif

  1583. }

  1584. 

  1585. void CarlaEngine::idleOsc() const noexcept

  1586. {

  1587. # ifdef HAVE_LIBLO

  1588.     pData->osc.idle();

  1589. # endif

  1590. }

  1591. 

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

  1593. {

  1594. # ifdef HAVE_LIBLO

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

  1596. # else

  1597.     return nullptr;

  1598. # endif

  1599. }

  1600. 

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

  1602. {

  1603. # ifdef HAVE_LIBLO

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

  1605. # else

  1606.     return nullptr;

  1607. # endif

  1608. }

  1609. #endif

  1610. 

  1611. // -----------------------------------------------------------------------

  1612. // Helper functions

  1613. 

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

  1615. {

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

  1617. }

  1618. 

  1619. // -----------------------------------------------------------------------

  1620. // Internal stuff

  1621. 

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

  1623. {

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

  1625. 

  1626. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1627.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  1628.         pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1629.     {

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

  1631.     }

  1632. #endif

  1633. 

  1634.     pData->time.updateAudioValues(newBufferSize, pData->sampleRate);

  1635. 

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

  1637.     {

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

  1639. 

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

  1641.         {

  1642.             plugin->tryLock(true);

  1643.             plugin->bufferSizeChanged(newBufferSize);

  1644.             plugin->unlock();

  1645.         }

  1646.     }

  1647. 

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

  1649. }

  1650. 

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

  1652. {

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

  1654. 

  1655. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1656.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  1657.         pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1658.     {

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

  1660.     }

  1661. #endif

  1662. 

  1663.     pData->time.updateAudioValues(pData->bufferSize, newSampleRate);

  1664. 

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

  1666.     {

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

  1668. 

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

  1670.         {

  1671.             plugin->tryLock(true);

  1672.             plugin->sampleRateChanged(newSampleRate);

  1673.             plugin->unlock();

  1674.         }

  1675.     }

  1676. 

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

  1678. }

  1679. 

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

  1681. {

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

  1683. 

  1684. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1685.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  1686.         pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1687.     {

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

  1689.     }

  1690. #endif

  1691. 

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

  1693.     {

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

  1695. 

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

  1697.             plugin->offlineModeChanged(isOfflineNow);

  1698.     }

  1699. }

  1700. 

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

  1702. {

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

  1704. 

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

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

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

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

  1709. }

  1710. 

  1711. void CarlaEngine::saveProjectInternal(water::MemoryOutputStream& outStream) const

  1712. {

  1713.     // send initial prepareForSave first, giving time for bridges to act

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

  1715.     {

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

  1717. 

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

  1719.         {

  1720. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1721.             // deactivate bridge client-side ping check, since some plugins block during save

  1722.             if (plugin->getHints() & PLUGIN_IS_BRIDGE)

  1723.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "__CarlaPingOnOff__", "false", false);

  1724. #endif

  1725.             plugin->prepareForSave();

  1726.         }

  1727.     }

  1728. 

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

  1730.     outStream << "<!DOCTYPE CARLA-PROJECT>\n";

  1731.     outStream << "<CARLA-PROJECT VERSION='2.0'>\n";

  1732. 

  1733.     const bool isPlugin(getType() == kEngineTypePlugin);

  1734.     const EngineOptions& options(pData->options);

  1735. 

  1736.     {

  1737.         MemoryOutputStream outSettings(1024);

  1738. 

  1739.         outSettings << " <EngineSettings>\n";

  1740. 

  1741.         outSettings << "  <ForceStereo>"         << bool2str(options.forceStereo)         << "</ForceStereo>\n";

  1742.         outSettings << "  <PreferPluginBridges>" << bool2str(options.preferPluginBridges) << "</PreferPluginBridges>\n";

  1743.         outSettings << "  <PreferUiBridges>"     << bool2str(options.preferUiBridges)     << "</PreferUiBridges>\n";

  1744.         outSettings << "  <UIsAlwaysOnTop>"      << bool2str(options.uisAlwaysOnTop)      << "</UIsAlwaysOnTop>\n";

  1745. 

  1746.         outSettings << "  <MaxParameters>"       << String(options.maxParameters)    << "</MaxParameters>\n";

  1747.         outSettings << "  <UIBridgesTimeout>"    << String(options.uiBridgesTimeout) << "</UIBridgesTimeout>\n";

  1748. 

  1749.         if (isPlugin)

  1750.         {

  1751.             outSettings << "  <LADSPA_PATH>" << xmlSafeString(options.pathLADSPA, true) << "</LADSPA_PATH>\n";

  1752.             outSettings << "  <DSSI_PATH>"   << xmlSafeString(options.pathDSSI,   true) << "</DSSI_PATH>\n";

  1753.             outSettings << "  <LV2_PATH>"    << xmlSafeString(options.pathLV2,    true) << "</LV2_PATH>\n";

  1754.             outSettings << "  <VST2_PATH>"   << xmlSafeString(options.pathVST2,   true) << "</VST2_PATH>\n";

  1755.             outSettings << "  <SF2_PATH>"    << xmlSafeString(options.pathSF2,    true) << "</SF2_PATH>\n";

  1756.             outSettings << "  <SFZ_PATH>"    << xmlSafeString(options.pathSFZ,    true) << "</SFZ_PATH>\n";

  1757.         }

  1758. 

  1759.         outSettings << " </EngineSettings>\n";

  1760.         outStream << outSettings;

  1761.     }

  1762. 

  1763.     if (pData->timeInfo.bbt.valid && ! isPlugin)

  1764.     {

  1765.         MemoryOutputStream outTransport(128);

  1766. 

  1767.         outTransport << "\n <Transport>\n";

  1768.         // outTransport << "  <BeatsPerBar>"    << pData->timeInfo.bbt.beatsPerBar    << "</BeatsPerBar>\n";

  1769.         outTransport << "  <BeatsPerMinute>" << pData->timeInfo.bbt.beatsPerMinute << "</BeatsPerMinute>\n";

  1770.         outTransport << " </Transport>\n";

  1771.         outStream << outTransport;

  1772.     }

  1773. 

  1774.     char strBuf[STR_MAX+1];

  1775. 

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

  1777.     {

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

  1779. 

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

  1781.         {

  1782.             MemoryOutputStream outPlugin(4096), streamPlugin;

  1783.             plugin->getStateSave(false).dumpToMemoryStream(streamPlugin);

  1784. 

  1785.             outPlugin << "\n";

  1786. 

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

  1788.             plugin->getRealName(strBuf);

  1789. 

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

  1791.                 outPlugin << " <!-- " << xmlSafeString(strBuf, true) << " -->\n";

  1792. 

  1793.             outPlugin << " <Plugin>\n";

  1794.             outPlugin << streamPlugin;

  1795.             outPlugin << " </Plugin>\n";

  1796.             outStream << outPlugin;

  1797.         }

  1798.     }

  1799. 

  1800. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1801.     // tell bridges we're done saving

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

  1803.     {

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

  1805. 

  1806.         if (plugin != nullptr && plugin->isEnabled() && (plugin->getHints() & PLUGIN_IS_BRIDGE) != 0)

  1807.             plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "__CarlaPingOnOff__", "true", false);

  1808.     }

  1809. 

  1810.     // save internal connections

  1811.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1812.     {

  1813.         if (const char* const* const patchbayConns = getPatchbayConnections(false))

  1814.         {

  1815.             MemoryOutputStream outPatchbay(2048);

  1816. 

  1817.             outPatchbay << "\n <Patchbay>\n";

  1818. 

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

  1820.             {

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

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

  1823. 

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

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

  1826. 

  1827.                 outPatchbay << "  <Connection>\n";

  1828.                 outPatchbay << "   <Source>" << xmlSafeString(connSource, true) << "</Source>\n";

  1829.                 outPatchbay << "   <Target>" << xmlSafeString(connTarget, true) << "</Target>\n";

  1830.                 outPatchbay << "  </Connection>\n";

  1831.             }

  1832. 

  1833.             outPatchbay << " </Patchbay>\n";

  1834.             outStream << outPatchbay;

  1835.         }

  1836.     }

  1837. 

  1838.     // if we're running inside some session-manager (and using JACK), let them handle the connections

  1839.     bool saveExternalConnections;

  1840. 

  1841.     /**/ if (isPlugin)

  1842.         saveExternalConnections = false;

  1843.     else if (std::strcmp(getCurrentDriverName(), "JACK") != 0)

  1844.         saveExternalConnections = true;

  1845.     else if (std::getenv("CARLA_DONT_MANAGE_CONNECTIONS") != nullptr)

  1846.         saveExternalConnections = false;

  1847.     else if (std::getenv("LADISH_APP_NAME") != nullptr)

  1848.         saveExternalConnections = false;

  1849.     else if (std::getenv("NSM_URL") != nullptr)

  1850.         saveExternalConnections = false;

  1851.     else

  1852.         saveExternalConnections = true;

  1853. 

  1854.     if (saveExternalConnections)

  1855.     {

  1856.         if (const char* const* const patchbayConns = getPatchbayConnections(true))

  1857.         {

  1858.             MemoryOutputStream outPatchbay(2048);

  1859. 

  1860.             outPatchbay << "\n <ExternalPatchbay>\n";

  1861. 

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

  1863.             {

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

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

  1866. 

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

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

  1869. 

  1870.                 outPatchbay << "  <Connection>\n";

  1871.                 outPatchbay << "   <Source>" << xmlSafeString(connSource, true) << "</Source>\n";

  1872.                 outPatchbay << "   <Target>" << xmlSafeString(connTarget, true) << "</Target>\n";

  1873.                 outPatchbay << "  </Connection>\n";

  1874.             }

  1875. 

  1876.             outPatchbay << " </ExternalPatchbay>\n";

  1877.             outStream << outPatchbay;

  1878.         }

  1879.     }

  1880. #endif

  1881. 

  1882.     outStream << "</CARLA-PROJECT>\n";

  1883. }

  1884. 

  1885. static String findBinaryInCustomPath(const char* const searchPath, const char* const binary)

  1886. {

  1887.     const StringArray searchPaths(StringArray::fromTokens(searchPath, CARLA_OS_SPLIT_STR, ""));

  1888. 

  1889.     // try direct filename first

  1890.     String jbinary(binary);

  1891. 

  1892.     // adjust for current platform

  1893. #ifdef CARLA_OS_WIN

  1894.     if (jbinary[0] == '/')

  1895.         jbinary = "C:" + jbinary.replaceCharacter('/', '\\');

  1896. #else

  1897.     if (jbinary[1] == ':' && (jbinary[2] == '\\' || jbinary[2] == '/'))

  1898.         jbinary = jbinary.substring(2).replaceCharacter('\\', '/');

  1899. #endif

  1900. 

  1901.     String filename = File(jbinary).getFileName();

  1902. 

  1903.     int searchFlags = File::findFiles|File::ignoreHiddenFiles;

  1904. #ifdef CARLA_OS_MAC

  1905.     if (filename.endsWithIgnoreCase(".vst"))

  1906.         searchFlags |= File::findDirectories;

  1907. #endif

  1908. 

  1909.     Array<File> results;

  1910.     for (const String *it=searchPaths.begin(), *end=searchPaths.end(); it != end; ++it)

  1911.     {

  1912.         const File path(*it);

  1913. 

  1914.         results.clear();

  1915.         path.findChildFiles(results, searchFlags, true, filename);

  1916. 

  1917.         if (results.size() > 0)

  1918.             return results.getFirst().getFullPathName();

  1919.     }

  1920. 

  1921.     // try changing extension

  1922. #if defined(CARLA_OS_MAC)

  1923.     if (filename.endsWithIgnoreCase(".dll") || filename.endsWithIgnoreCase(".so"))

  1924.         filename = File(jbinary).getFileNameWithoutExtension() + ".dylib";

  1925. #elif defined(CARLA_OS_WIN)

  1926.     if (filename.endsWithIgnoreCase(".dylib") || filename.endsWithIgnoreCase(".so"))

  1927.         filename = File(jbinary).getFileNameWithoutExtension() + ".dll";

  1928. #else

  1929.     if (filename.endsWithIgnoreCase(".dll") || filename.endsWithIgnoreCase(".dylib"))

  1930.         filename = File(jbinary).getFileNameWithoutExtension() + ".so";

  1931. #endif

  1932.     else

  1933.         return String();

  1934. 

  1935.     for (const String *it=searchPaths.begin(), *end=searchPaths.end(); it != end; ++it)

  1936.     {

  1937.         const File path(*it);

  1938. 

  1939.         results.clear();

  1940.         path.findChildFiles(results, searchFlags, true, filename);

  1941. 

  1942.         if (results.size() > 0)

  1943.             return results.getFirst().getFullPathName();

  1944.     }

  1945. 

  1946.     return String();

  1947. }

  1948. 

  1949. bool CarlaEngine::loadProjectInternal(water::XmlDocument& xmlDoc)

  1950. {

  1951.     ScopedPointer<XmlElement> xmlElement(xmlDoc.getDocumentElement(true));

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

  1953. 

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

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

  1956. 

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

  1958.     {

  1959.         callback(ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0.0f, nullptr);

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

  1961.         return false;

  1962.     }

  1963. 

  1964. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1965.     const ScopedValueSetter<bool> _svs(pData->loadingProject, true, false);

  1966. #endif

  1967. 

  1968.     // completely load file

  1969.     xmlElement = xmlDoc.getDocumentElement(false);

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

  1971. 

  1972.     if (pData->aboutToClose)

  1973.         return true;

  1974. 

  1975.     const bool isPlugin(getType() == kEngineTypePlugin);

  1976. 

  1977.     // load engine settings first of all

  1978.     if (XmlElement* const elem = isPreset ? nullptr : xmlElement->getChildByName("EngineSettings"))

  1979.     {

  1980.         for (XmlElement* settElem = elem->getFirstChildElement(); settElem != nullptr; settElem = settElem->getNextElement())

  1981.         {

  1982.             const String& tag(settElem->getTagName());

  1983.             const String  text(settElem->getAllSubText().trim());

  1984. 

  1985.             /** some settings might be incorrect or require extra work,

  1986.                 so we call setOption rather than modifying them direly */

  1987. 

  1988.             int option = -1;

  1989.             int value  = 0;

  1990.             const char* valueStr = nullptr;

  1991. 

  1992.             /**/ if (tag == "ForceStereo")

  1993.             {

  1994.                 option = ENGINE_OPTION_FORCE_STEREO;

  1995.                 value  = text == "true" ? 1 : 0;

  1996.             }

  1997.             else if (tag == "PreferPluginBridges")

  1998.             {

  1999.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

  2000.                 value  = text == "true" ? 1 : 0;

  2001.             }

  2002.             else if (tag == "PreferUiBridges")

  2003.             {

  2004.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

  2005.                 value  = text == "true" ? 1 : 0;

  2006.             }

  2007.             else if (tag == "UIsAlwaysOnTop")

  2008.             {

  2009.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

  2010.                 value  = text == "true" ? 1 : 0;

  2011.             }

  2012.             else if (tag == "MaxParameters")

  2013.             {

  2014.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2015.                 value  = text.getIntValue();

  2016.             }

  2017.             else if (tag == "UIBridgesTimeout")

  2018.             {

  2019.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2020.                 value  = text.getIntValue();

  2021.             }

  2022.             else if (isPlugin)

  2023.             {

  2024.                 /**/ if (tag == "LADSPA_PATH")

  2025.                 {

  2026.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2027.                     value    = PLUGIN_LADSPA;

  2028.                     valueStr = text.toRawUTF8();

  2029.                 }

  2030.                 else if (tag == "DSSI_PATH")

  2031.                 {

  2032.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2033.                     value    = PLUGIN_DSSI;

  2034.                     valueStr = text.toRawUTF8();

  2035.                 }

  2036.                 else if (tag == "LV2_PATH")

  2037.                 {

  2038.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2039.                     value    = PLUGIN_LV2;

  2040.                     valueStr = text.toRawUTF8();

  2041.                 }

  2042.                 else if (tag == "VST2_PATH")

  2043.                 {

  2044.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2045.                     value    = PLUGIN_VST2;

  2046.                     valueStr = text.toRawUTF8();

  2047.                 }

  2048.                 else if (tag == "SF2_PATH")

  2049.                 {

  2050.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2051.                     value    = PLUGIN_SF2;

  2052.                     valueStr = text.toRawUTF8();

  2053.                 }

  2054.                 else if (tag == "SFZ_PATH")

  2055.                 {

  2056.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2057.                     value    = PLUGIN_SFZ;

  2058.                     valueStr = text.toRawUTF8();

  2059.                 }

  2060.             }

  2061. 

  2062.             if (option == -1)

  2063.             {

  2064.                 // check old stuff, unhandled now

  2065.                 if (tag == "GIG_PATH")

  2066.                     continue;

  2067. 

  2068.                 // hmm something is wrong..

  2069.                 carla_stderr2("CarlaEngine::loadProjectInternal() - Unhandled option '%s'", tag.toRawUTF8());

  2070.                 continue;

  2071.             }

  2072. 

  2073.             setOption(static_cast<EngineOption>(option), value, valueStr);

  2074.         }

  2075.     }

  2076. 

  2077.     if (pData->aboutToClose)

  2078.         return true;

  2079. 

  2080.     // now setup transport

  2081.     if (XmlElement* const elem = (isPreset || isPlugin) ? nullptr : xmlElement->getChildByName("Transport"))

  2082.     {

  2083.         if (XmlElement* const bpmElem = elem->getChildByName("BeatsPerMinute"))

  2084.         {

  2085.             const String bpmText(bpmElem->getAllSubText().trim());

  2086.             const double bpm = bpmText.getDoubleValue();

  2087. 

  2088.             // some sane limits

  2089.             if (bpm >= 20.0 && bpm < 400.0)

  2090.                 pData->time.setBPM(bpm);

  2091.         }

  2092.     }

  2093. 

  2094.     if (pData->aboutToClose)

  2095.         return true;

  2096. 

  2097.     // and we handle plugins

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

  2099.     {

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

  2101. 

  2102.         if (isPreset || tagName == "Plugin")

  2103.         {

  2104.             CarlaStateSave stateSave;

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

  2106. 

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

  2108. 

  2109.             if (pData->aboutToClose)

  2110.                 return true;

  2111. 

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

  2113. 

  2114. #ifndef BUILD_BRIDGE

  2115.             // compatibility code to load projects with GIG files

  2116.             // FIXME Remove on 2.1 release

  2117.             if (std::strcmp(stateSave.type, "GIG") == 0)

  2118.             {

  2119.                 if (addPlugin(PLUGIN_LV2, "", stateSave.name, "http://linuxsampler.org/plugins/linuxsampler", 0, nullptr))

  2120.                 {

  2121.                     const uint pluginId = pData->curPluginCount;

  2122. 

  2123.                     if (CarlaPlugin* const plugin = pData->plugins[pluginId].plugin)

  2124.                     {

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

  2126. 

  2127.                         if (pData->aboutToClose)

  2128.                             return true;

  2129. 

  2130.                         String lsState;

  2131.                         lsState << "0.35\n";

  2132.                         lsState << "18 0 Chromatic\n";

  2133.                         lsState << "18 1 Drum Kits\n";

  2134.                         lsState << "20 0\n";

  2135.                         lsState << "0 1 " << stateSave.binary << "\n";

  2136.                         lsState << "0 0 0 0 1 0 GIG\n";

  2137. 

  2138.                         plugin->setCustomData(LV2_ATOM__String, "http://linuxsampler.org/schema#state-string", lsState.toRawUTF8(), true);

  2139.                         plugin->restoreLV2State();

  2140. 

  2141.                         plugin->setDryWet(stateSave.dryWet, true, true);

  2142.                         plugin->setVolume(stateSave.volume, true, true);

  2143.                         plugin->setBalanceLeft(stateSave.balanceLeft, true, true);

  2144.                         plugin->setBalanceRight(stateSave.balanceRight, true, true);

  2145.                         plugin->setPanning(stateSave.panning, true, true);

  2146.                         plugin->setCtrlChannel(stateSave.ctrlChannel, true, true);

  2147.                         plugin->setActive(stateSave.active, true, true);

  2148. 

  2149.                         ++pData->curPluginCount;

  2150. 

  2151.                         plugin->setEnabled(true);

  2152.                         callback(ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0.0f, plugin->getName());

  2153. 

  2154.                         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2155.                             pData->graph.addPlugin(plugin);

  2156.                     }

  2157.                     else

  2158.                     {

  2159.                         carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  2160.                     }

  2161.                 }

  2162.                 else

  2163.                 {

  2164.                     carla_stderr2("Failed to load a linuxsampler LV2 plugin, GIG file won't be loaded");

  2165.                 }

  2166. 

  2167.                 continue;

  2168.             }

  2169. #endif

  2170. 

  2171.             const void* extraStuff    = nullptr;

  2172.             static const char kTrue[] = "true";

  2173. 

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

  2175. 

  2176.             switch (ptype)

  2177.             {

  2178.             case PLUGIN_SF2:

  2179.                 if (CarlaString(stateSave.label).endsWith(" (16 outs)"))

  2180.                     extraStuff = kTrue;

  2181.                 // fall through

  2182.             case PLUGIN_LADSPA:

  2183.             case PLUGIN_DSSI:

  2184.             case PLUGIN_VST2:

  2185.             case PLUGIN_SFZ:

  2186.                 if (stateSave.binary != nullptr && stateSave.binary[0] != '\0' &&

  2187.                     ! (File::isAbsolutePath(stateSave.binary) && File(stateSave.binary).exists()))

  2188.                 {

  2189.                     const char* searchPath;

  2190. 

  2191.                     switch (ptype)

  2192.                     {

  2193.                     case PLUGIN_LADSPA: searchPath = pData->options.pathLADSPA; break;

  2194.                     case PLUGIN_DSSI:   searchPath = pData->options.pathDSSI;   break;

  2195.                     case PLUGIN_VST2:   searchPath = pData->options.pathVST2;   break;

  2196.                     case PLUGIN_SF2:    searchPath = pData->options.pathSF2;    break;

  2197.                     case PLUGIN_SFZ:    searchPath = pData->options.pathSFZ;    break;

  2198.                     default:            searchPath = nullptr;                   break;

  2199.                     }

  2200. 

  2201.                     if (searchPath != nullptr && searchPath[0] != '\0')

  2202.                     {

  2203.                         carla_stderr("Plugin binary '%s' doesn't exist on this filesystem, let's look for it...",

  2204.                                      stateSave.binary);

  2205. 

  2206.                         String result = findBinaryInCustomPath(searchPath, stateSave.binary);

  2207. 

  2208.                         if (result.isEmpty())

  2209.                         {

  2210.                             switch (ptype)

  2211.                             {

  2212.                             case PLUGIN_LADSPA: searchPath = std::getenv("LADSPA_PATH"); break;

  2213.                             case PLUGIN_DSSI:   searchPath = std::getenv("DSSI_PATH");   break;

  2214.                             case PLUGIN_VST2:   searchPath = std::getenv("VST_PATH");    break;

  2215.                             case PLUGIN_SF2:    searchPath = std::getenv("SF2_PATH");    break;

  2216.                             case PLUGIN_SFZ:    searchPath = std::getenv("SFZ_PATH");    break;

  2217.                             default:            searchPath = nullptr;                    break;

  2218.                             }

  2219. 

  2220.                             if (searchPath != nullptr && searchPath[0] != '\0')

  2221.                                 result = findBinaryInCustomPath(searchPath, stateSave.binary);

  2222.                         }

  2223. 

  2224.                         if (result.isNotEmpty())

  2225.                         {

  2226.                             delete[] stateSave.binary;

  2227.                             stateSave.binary = carla_strdup(result.toRawUTF8());

  2228.                             carla_stderr("Found it! :)");

  2229.                         }

  2230.                         else

  2231.                         {

  2232.                             carla_stderr("Damn, we failed... :(");

  2233.                         }

  2234.                     }

  2235.                 }

  2236.                 break;

  2237.             default:

  2238.                 break;

  2239.             }

  2240. 

  2241.             if (addPlugin(getBinaryTypeFromFile(stateSave.binary), ptype, stateSave.binary,

  2242.                           stateSave.name, stateSave.label, stateSave.uniqueId, extraStuff, stateSave.options))

  2243.             {

  2244. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2245.                 const uint pluginId = pData->curPluginCount;

  2246. #else

  2247.                 const uint pluginId = 0;

  2248. #endif

  2249. 

  2250.                 if (CarlaPlugin* const plugin = pData->plugins[pluginId].plugin)

  2251.                 {

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

  2253. 

  2254.                     if (pData->aboutToClose)

  2255.                         return true;

  2256. 

  2257.                     // deactivate bridge client-side ping check, since some plugins block during load

  2258.                     if ((plugin->getHints() & PLUGIN_IS_BRIDGE) != 0 && ! isPreset)

  2259.                         plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "__CarlaPingOnOff__", "false", false);

  2260. 

  2261.                     plugin->loadStateSave(stateSave);

  2262. 

  2263.                     /* NOTE: The following code is the same as the end of addPlugin().

  2264.                      *       When project is loading we do not enable the plugin right away,

  2265.                      *        as we want to load state first.

  2266.                      */

  2267.                     plugin->setEnabled(true);

  2268. 

  2269.                     ++pData->curPluginCount;

  2270.                     callback(ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0.0f, plugin->getName());

  2271. 

  2272. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2273.                     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2274.                         pData->graph.addPlugin(plugin);

  2275. #endif

  2276.                 }

  2277.                 else

  2278.                 {

  2279.                     carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  2280.                 }

  2281.             }

  2282.             else

  2283.             {

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

  2285.             }

  2286.         }

  2287. 

  2288.         if (isPreset)

  2289.         {

  2290.             callback(ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0.0f, nullptr);

  2291.             return true;

  2292.         }

  2293.     }

  2294. 

  2295. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2296.     // tell bridges we're done loading

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

  2298.     {

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

  2300. 

  2301.         if (plugin != nullptr && plugin->isEnabled() && (plugin->getHints() & PLUGIN_IS_BRIDGE) != 0)

  2302.             plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "__CarlaPingOnOff__", "true", false);

  2303.     }

  2304. 

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

  2306. 

  2307.     if (pData->aboutToClose)

  2308.         return true;

  2309. 

  2310.     // and now we handle connections (internal)

  2311.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2312.     {

  2313.         const bool isUsingExternal(pData->graph.isUsingExternal());

  2314. 

  2315.         if (XmlElement* const elem = xmlElement->getChildByName("Patchbay"))

  2316.         {

  2317.             CarlaString sourcePort, targetPort;

  2318. 

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

  2320.             {

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

  2322. 

  2323.                 if (patchTag != "Connection")

  2324.                     continue;

  2325. 

  2326.                 sourcePort.clear();

  2327.                 targetPort.clear();

  2328. 

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

  2330.                 {

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

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

  2333. 

  2334.                     /**/ if (tag == "Source")

  2335.                         sourcePort = xmlSafeString(text, false).toRawUTF8();

  2336.                     else if (tag == "Target")

  2337.                         targetPort = xmlSafeString(text, false).toRawUTF8();

  2338.                 }

  2339. 

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

  2341.                     restorePatchbayConnection(false, sourcePort, targetPort, !isUsingExternal);

  2342.             }

  2343.         }

  2344. 

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

  2346. 

  2347.         if (pData->aboutToClose)

  2348.             return true;

  2349.     }

  2350. 

  2351.     // if we're running inside some session-manager (and using JACK), let them handle the external connections

  2352.     bool loadExternalConnections;

  2353. 

  2354.     /**/ if (isPlugin)

  2355.         loadExternalConnections = false;

  2356.     else if (std::strcmp(getCurrentDriverName(), "JACK") != 0)

  2357.         loadExternalConnections = true;

  2358.     else if (std::getenv("CARLA_DONT_MANAGE_CONNECTIONS") != nullptr)

  2359.         loadExternalConnections = false;

  2360.     else if (std::getenv("LADISH_APP_NAME") != nullptr)

  2361.         loadExternalConnections = false;

  2362.     else if (std::getenv("NSM_URL") != nullptr)

  2363.         loadExternalConnections = false;

  2364.     else

  2365.         loadExternalConnections = true;

  2366. 

  2367.     // plus external connections too

  2368.     if (loadExternalConnections)

  2369.     {

  2370.         const bool isUsingExternal(pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY ||

  2371.                                    pData->graph.isUsingExternal());

  2372. 

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

  2374.         {

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

  2376. 

  2377.             // check if we want to load patchbay-mode connections into an external (multi-client) graph

  2378.             if (tagName == "Patchbay")

  2379.             {

  2380.                 if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2381.                     continue;

  2382.             }

  2383.             // or load external patchbay connections

  2384.             else if (tagName != "ExternalPatchbay")

  2385.             {

  2386.                 continue;

  2387.             }

  2388. 

  2389.             CarlaString sourcePort, targetPort;

  2390. 

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

  2392.             {

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

  2394. 

  2395.                 if (patchTag != "Connection")

  2396.                     continue;

  2397. 

  2398.                 sourcePort.clear();

  2399.                 targetPort.clear();

  2400. 

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

  2402.                 {

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

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

  2405. 

  2406.                     /**/ if (tag == "Source")

  2407.                         sourcePort = xmlSafeString(text, false).toRawUTF8();

  2408.                     else if (tag == "Target")

  2409.                         targetPort = xmlSafeString(text, false).toRawUTF8();

  2410.                 }

  2411. 

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

  2413.                     restorePatchbayConnection(true, sourcePort, targetPort, isUsingExternal);

  2414.             }

  2415.             break;

  2416.         }

  2417.     }

  2418. 

  2419. #endif

  2420. 

  2421.     callback(ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0.0f, nullptr);

  2422.     return true;

  2423. }

  2424. 

  2425. // -----------------------------------------------------------------------

  2426. 

  2427. CARLA_BACKEND_END_NAMESPACE