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

3525 lines
120KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2022 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 "CarlaEngineClient.hpp"

  26. #include "CarlaEngineInit.hpp"

  27. #include "CarlaEngineInternal.hpp"

  28. #include "CarlaPlugin.hpp"

  29. 

  30. #include "CarlaBackendUtils.hpp"

  31. #include "CarlaBinaryUtils.hpp"

  32. #include "CarlaEngineUtils.hpp"

  33. #include "CarlaMathUtils.hpp"

  34. #include "CarlaPipeUtils.hpp"

  35. #include "CarlaProcessUtils.hpp"

  36. #include "CarlaScopeUtils.hpp"

  37. #include "CarlaStateUtils.hpp"

  38. #include "CarlaMIDI.h"

  39. 

  40. #include "jackbridge/JackBridge.hpp"

  41. 

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

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

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

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

  46. 

  47. #ifdef CARLA_OS_MAC

  48. # include "CarlaMacUtils.hpp"

  49. # if defined(CARLA_OS_64BIT) && defined(HAVE_LIBMAGIC) && ! defined(BUILD_BRIDGE_ALTERNATIVE_ARCH)

  50. #  define ADAPT_FOR_APPLE_SILLICON

  51. # endif

  52. #endif

  53. 

  54. #include <map>

  55. 

  56. // FIXME Remove on 2.1 release

  57. #include "lv2/atom.h"

  58. 

  59. using water::Array;

  60. using water::CharPointer_UTF8;

  61. using water::File;

  62. using water::MemoryOutputStream;

  63. using water::String;

  64. using water::StringArray;

  65. using water::XmlDocument;

  66. using water::XmlElement;

  67. 

  68. // #define SFZ_FILES_USING_SFIZZ

  69. 

  70. CARLA_BACKEND_START_NAMESPACE

  71. 

  72. // -----------------------------------------------------------------------

  73. // Carla Engine

  74. 

  75. CarlaEngine::CarlaEngine()

  76.     : pData(new ProtectedData(this))

  77. {

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

  79. }

  80. 

  81. CarlaEngine::~CarlaEngine()

  82. {

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

  84. 

  85.     delete pData;

  86. }

  87. 

  88. // -----------------------------------------------------------------------

  89. // Static calls

  90. 

  91. uint CarlaEngine::getDriverCount()

  92. {

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

  94.     using namespace EngineInit;

  95. 

  96.     uint count = 0;

  97. 

  98. #ifndef STATIC_PLUGIN_TARGET

  99.     if (jackbridge_is_ok())

  100.         count += 1;

  101. #endif

  102. 

  103. #ifndef BUILD_BRIDGE

  104. # ifdef USING_JUCE_AUDIO_DEVICES

  105.     count += getJuceApiCount();

  106. # endif

  107. # ifdef USING_RTAUDIO

  108.     count += getRtAudioApiCount();

  109. # endif

  110. #endif

  111. 

  112.     return count;

  113. }

  114. 

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

  116. {

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

  118.     using namespace EngineInit;

  119. 

  120. #ifndef STATIC_PLUGIN_TARGET

  121.     uint index = index2;

  122. 

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

  124.         return "JACK";

  125. #endif

  126. 

  127. #ifndef BUILD_BRIDGE

  128. # ifdef USING_JUCE_AUDIO_DEVICES

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

  130.     {

  131.         if (index < count)

  132.             return getJuceApiName(index);

  133.         index -= count;

  134.     }

  135. # endif

  136. # ifdef USING_RTAUDIO

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

  138.     {

  139.         if (index < count)

  140.             return getRtAudioApiName(index);

  141.     }

  142. # endif

  143. #endif

  144. 

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

  146.     return nullptr;

  147. }

  148. 

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

  150. {

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

  152.     using namespace EngineInit;

  153. 

  154. #ifndef STATIC_PLUGIN_TARGET

  155.     uint index = index2;

  156. 

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

  158.     {

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

  160.         return ret;

  161.     }

  162. #endif

  163. 

  164. #ifndef BUILD_BRIDGE

  165. # ifdef USING_JUCE_AUDIO_DEVICES

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

  167.     {

  168.         if (index < count)

  169.             return getJuceApiDeviceNames(index);

  170.         index -= count;

  171.     }

  172. # endif

  173. # ifdef USING_RTAUDIO

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

  175.     {

  176.         if (index < count)

  177.             return getRtAudioApiDeviceNames(index);

  178.     }

  179. # endif

  180. #endif

  181. 

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

  183.     return nullptr;

  184. }

  185. 

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

  187. {

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

  189.     using namespace EngineInit;

  190. 

  191. #ifndef STATIC_PLUGIN_TARGET

  192.     uint index = index2;

  193. 

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

  195.     {

  196.         static EngineDriverDeviceInfo devInfo;

  197.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  198.         devInfo.bufferSizes = nullptr;

  199.         devInfo.sampleRates = nullptr;

  200.         return &devInfo;

  201.     }

  202. #endif

  203. 

  204. #ifndef BUILD_BRIDGE

  205. # ifdef USING_JUCE_AUDIO_DEVICES

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

  207.     {

  208.         if (index < count)

  209.             return getJuceDeviceInfo(index, deviceName);

  210.         index -= count;

  211.     }

  212. # endif

  213. # ifdef USING_RTAUDIO

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

  215.     {

  216.         if (index < count)

  217.             return getRtAudioDeviceInfo(index, deviceName);

  218.     }

  219. # endif

  220. #endif

  221. 

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

  223.     return nullptr;

  224. }

  225. 

  226. bool CarlaEngine::showDriverDeviceControlPanel(const uint index2, const char* const deviceName)

  227. {

  228.     carla_debug("CarlaEngine::showDriverDeviceControlPanel(%i, \"%s\")", index2, deviceName);

  229.     using namespace EngineInit;

  230. 

  231. #ifndef STATIC_PLUGIN_TARGET

  232.     uint index = index2;

  233. 

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

  235.     {

  236.         return false;

  237.     }

  238. #endif

  239. 

  240. #ifndef BUILD_BRIDGE

  241. # ifdef USING_JUCE_AUDIO_DEVICES

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

  243.     {

  244.         if (index < count)

  245.             return showJuceDeviceControlPanel(index, deviceName);

  246.         index -= count;

  247.     }

  248. # endif

  249. # ifdef USING_RTAUDIO

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

  251.     {

  252.         if (index < count)

  253.             return false;

  254.     }

  255. # endif

  256. #endif

  257. 

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

  259.     return false;

  260. }

  261. 

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

  263. {

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

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

  266.     using namespace EngineInit;

  267. 

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

  269.         return newJack();

  270. 

  271. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  273.         return newDummy();

  274. #endif

  275. 

  276. #ifndef BUILD_BRIDGE

  277. # ifdef USING_JUCE_AUDIO_DEVICES

  278.     // -------------------------------------------------------------------

  279.     // linux

  280. 

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

  282.         return newJuce(AUDIO_API_ALSA);

  283. 

  284.     // -------------------------------------------------------------------

  285.     // macos

  286. 

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

  288.         return newJuce(AUDIO_API_COREAUDIO);

  289. 

  290.     // -------------------------------------------------------------------

  291.     // windows

  292. 

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

  294.         return newJuce(AUDIO_API_ASIO);

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

  296.         return newJuce(AUDIO_API_DIRECTSOUND);

  297.     if (std::strcmp(driverName, "WASAPI") == 0 || std::strcmp(driverName, "Windows Audio") == 0)

  298.         return newJuce(AUDIO_API_WASAPI);

  299. # endif

  300. # ifdef USING_RTAUDIO

  301.     // -------------------------------------------------------------------

  302.     // common

  303. 

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

  305.         return newRtAudio(AUDIO_API_JACK);

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

  307.         return newRtAudio(AUDIO_API_OSS);

  308. 

  309.     // -------------------------------------------------------------------

  310.     // linux

  311. 

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

  313.         return newRtAudio(AUDIO_API_ALSA);

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

  315.         return newRtAudio(AUDIO_API_PULSEAUDIO);

  316. 

  317.     // -------------------------------------------------------------------

  318.     // macos

  319. 

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

  321.         return newRtAudio(AUDIO_API_COREAUDIO);

  322. 

  323.     // -------------------------------------------------------------------

  324.     // windows

  325. 

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

  327.         return newRtAudio(AUDIO_API_ASIO);

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

  329.         return newRtAudio(AUDIO_API_DIRECTSOUND);

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

  331.         return newRtAudio(AUDIO_API_WASAPI);

  332. # endif

  333. #endif

  334. 

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

  336.     return nullptr;

  337. }

  338. 

  339. // -----------------------------------------------------------------------

  340. // Constant values

  341. 

  342. uint CarlaEngine::getMaxClientNameSize() const noexcept

  343. {

  344.     return STR_MAX/2;

  345. }

  346. 

  347. uint CarlaEngine::getMaxPortNameSize() const noexcept

  348. {

  349.     return STR_MAX;

  350. }

  351. 

  352. uint CarlaEngine::getCurrentPluginCount() const noexcept

  353. {

  354.     return pData->curPluginCount;

  355. }

  356. 

  357. uint CarlaEngine::getMaxPluginNumber() const noexcept

  358. {

  359.     return pData->maxPluginNumber;

  360. }

  361. 

  362. // -----------------------------------------------------------------------

  363. // Virtual, per-engine type calls

  364. 

  365. bool CarlaEngine::close()

  366. {

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

  368. 

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

  370.     {

  371.         pData->aboutToClose = true;

  372.         removeAllPlugins();

  373.     }

  374. 

  375.     pData->close();

  376. 

  377.     callback(true, true, ENGINE_CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0, 0.0f, nullptr);

  378.     return true;

  379. }

  380. 

  381. bool CarlaEngine::usesConstantBufferSize() const noexcept

  382. {

  383.     return true;

  384. }

  385. 

  386. void CarlaEngine::idle() noexcept

  387. {

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

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

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

  391. 

  392.     const bool engineNotRunning = !isRunning();

  393. 

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

  395.     {

  396.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  397.         {

  398.             if (plugin->isEnabled())

  399.             {

  400.                 const uint hints = plugin->getHints();

  401. 

  402.                 if (engineNotRunning)

  403.                 {

  404.                     try {

  405.                         plugin->idle();

  406.                     } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin idle");

  407. 

  408.                     if (hints & PLUGIN_HAS_CUSTOM_UI)

  409.                     {

  410.                         try {

  411.                             plugin->uiIdle();

  412.                         } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  413.                     }

  414.                 }

  415.                 else if ((hints & PLUGIN_HAS_CUSTOM_UI) != 0 && (hints & PLUGIN_NEEDS_UI_MAIN_THREAD) != 0)

  416.                 {

  417.                     try {

  418.                         plugin->uiIdle();

  419.                     } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  420.                 }

  421.             }

  422.         }

  423.     }

  424. 

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

  426.     pData->osc.idle();

  427. #endif

  428. 

  429.     pData->deletePluginsAsNeeded();

  430. }

  431. 

  432. CarlaEngineClient* CarlaEngine::addClient(CarlaPluginPtr plugin)

  433. {

  434. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  435.     return new CarlaEngineClientForStandalone(*this, pData->graph, plugin);

  436. #else

  437.     return new CarlaEngineClientForBridge(*this);

  438. 

  439.     // unused

  440.     (void)plugin;

  441. #endif

  442. }

  443. 

  444. float CarlaEngine::getDSPLoad() const noexcept

  445. {

  446. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  447.     return pData->dspLoad;

  448. #else

  449.     return 0.0f;

  450. #endif

  451. }

  452. 

  453. uint32_t CarlaEngine::getTotalXruns() const noexcept

  454. {

  455. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  456.     return pData->xruns;

  457. #else

  458.     return 0;

  459. #endif

  460. }

  461. 

  462. void CarlaEngine::clearXruns() const noexcept

  463. {

  464. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  465.     pData->xruns = 0;

  466. #endif

  467. }

  468. 

  469. bool CarlaEngine::showDeviceControlPanel() const noexcept

  470. {

  471.     return false;

  472. }

  473. 

  474. bool CarlaEngine::setBufferSizeAndSampleRate(const uint, const double)

  475. {

  476.     return false;

  477. }

  478. 

  479. // -----------------------------------------------------------------------

  480. // Plugin management

  481. 

  482. bool CarlaEngine::addPlugin(const BinaryType btype,

  483.                             const PluginType ptype,

  484.                             const char* const filename,

  485.                             const char* const name,

  486.                             const char* const label,

  487.                             const int64_t uniqueId,

  488.                             const void* const extra,

  489.                             const uint options)

  490. {

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

  492. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  495. #endif

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

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

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

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

  500.     carla_debug("CarlaEngine::addPlugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p, %u)",

  501.                 btype, BinaryType2Str(btype), ptype, PluginType2Str(ptype), filename, name, label, uniqueId, extra, options);

  502. 

  503. #ifndef CARLA_OS_WIN

  504.     if (ptype != PLUGIN_JACK && ptype != PLUGIN_LV2 && filename != nullptr && filename[0] != '\0') {

  505.         CARLA_SAFE_ASSERT_RETURN_ERR(filename[0] == CARLA_OS_SEP || filename[0] == '.' || filename[0] == '~', "Invalid plugin filename");

  506.     }

  507. #endif

  508. 

  509.     uint id;

  510. 

  511. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  512.     CarlaPluginPtr oldPlugin;

  513. 

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

  515.     {

  516.         id = pData->nextPluginId;

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

  518. 

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

  520. 

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

  522.     }

  523.     else

  524. #endif

  525.     {

  526.         id = pData->curPluginCount;

  527. 

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

  529.         {

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

  531.             return false;

  532.         }

  533. 

  534. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  536. #endif

  537.     }

  538. 

  539.     CarlaPlugin::Initializer initializer = {

  540.         this,

  541.         id,

  542.         filename,

  543.         name,

  544.         label,

  545.         uniqueId,

  546.         options

  547.     };

  548. 

  549.     CarlaPluginPtr plugin;

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

  551. 

  552.     if (bridgeBinary.isNotEmpty())

  553.     {

  554. #ifndef CARLA_OS_WIN

  555.         if (btype == BINARY_NATIVE)

  556.         {

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

  558.         }

  559.         else

  560. #endif

  561.         {

  562.             switch (btype)

  563.             {

  564.             case BINARY_POSIX32:

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

  566.                 break;

  567.             case BINARY_POSIX64:

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

  569.                 break;

  570.             case BINARY_WIN32:

  571. #if defined(CARLA_OS_WIN) && !defined(CARLA_OS_64BIT)

  572.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-native.exe";

  573. #else

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

  575. #endif

  576.                 break;

  577.             case BINARY_WIN64:

  578. #if defined(CARLA_OS_WIN) && defined(CARLA_OS_64BIT)

  579.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-native.exe";

  580. #else

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

  582. #endif

  583.                 break;

  584.             default:

  585.                 bridgeBinary.clear();

  586.                 break;

  587.             }

  588.         }

  589. 

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

  591.             bridgeBinary.clear();

  592.     }

  593. 

  594.     const bool canBeBridged = ptype != PLUGIN_INTERNAL

  595.                            && ptype != PLUGIN_DLS

  596.                            && ptype != PLUGIN_GIG

  597.                            && ptype != PLUGIN_SF2

  598.                            && ptype != PLUGIN_SFZ

  599.                            && ptype != PLUGIN_JACK;

  600. 

  601.     // Prefer bridges for some specific plugins

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

  603.     const char* needsArchBridge = nullptr;

  604. 

  605. #ifdef CARLA_OS_MAC

  606.     // Plugin might be in quarentine due to Apple stupid notarization rules, let's remove that if possible

  607.     if (canBeBridged && ptype != PLUGIN_LV2 && ptype != PLUGIN_AU)

  608.         removeFileFromQuarantine(filename);

  609. #endif

  610. 

  611. #ifndef BUILD_BRIDGE

  612.     if (canBeBridged && ! preferBridges)

  613.     {

  614. # if 0

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

  616.         {

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

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

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

  620.             {

  621.                 preferBridges = true;

  622.             }

  623.         }

  624. # endif

  625. # ifdef ADAPT_FOR_APPLE_SILLICON

  626.         // see if this binary needs bridging

  627.         if (ptype == PLUGIN_VST2 || ptype == PLUGIN_VST3)

  628.         {

  629.             if (const char* const vst2Binary = findBinaryInBundle(filename))

  630.             {

  631.                 const CarlaMagic magic;

  632.                 if (const char* const output = magic.getFileDescription(vst2Binary))

  633.                 {

  634.                     carla_stdout("VST binary magic output is '%s'", output);

  635. #  ifdef __aarch64__

  636.                     if (std::strstr(output, "arm64") == nullptr && std::strstr(output, "x86_64") != nullptr)

  637.                         needsArchBridge = "x86_64";

  638. #  else

  639.                     if (std::strstr(output, "x86_64") == nullptr && std::strstr(output, "arm64") != nullptr)

  640.                         needsArchBridge = "arm64";

  641. #  endif

  642.                 }

  643.                 else

  644.                 {

  645.                     carla_stdout("VST binary magic output is null");

  646.                 }

  647.             }

  648.             else

  649.             {

  650.                 carla_stdout("Search for binary in VST bundle failed");

  651.             }

  652.         }

  653. # endif

  654.     }

  655. #endif // ! BUILD_BRIDGE

  656. 

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

  658.     {

  659.         if (bridgeBinary.isNotEmpty())

  660.         {

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

  662.         }

  663.         else

  664.         {

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

  666.             return false;

  667.         }

  668.     }

  669.     else

  670.     {

  671. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  672.         bool use16Outs;

  673. #endif

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

  675. 

  676.         // Some stupid plugins mess up with global signals, err!!

  677.         const CarlaSignalRestorer csr;

  678. 

  679.         switch (ptype)

  680.         {

  681.         case PLUGIN_NONE:

  682.             break;

  683. 

  684.         case PLUGIN_LADSPA:

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

  686.             break;

  687. 

  688.         case PLUGIN_DSSI:

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

  690.             break;

  691. 

  692.         case PLUGIN_LV2:

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

  694.             break;

  695. 

  696.         case PLUGIN_VST2:

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

  698.             break;

  699. 

  700.         case PLUGIN_VST3:

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

  702.             break;

  703. 

  704.         case PLUGIN_AU:

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

  706.             break;

  707. 

  708.         case PLUGIN_JSFX:

  709.             setLastError("Not implemented yet");

  710.             break;

  711. 

  712. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  713.         case PLUGIN_INTERNAL:

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

  715.             break;

  716. 

  717.         case PLUGIN_DLS:

  718.         case PLUGIN_GIG:

  719.         case PLUGIN_SF2:

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

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

  722.             break;

  723. 

  724.         case PLUGIN_SFZ:

  725. # ifdef SFZ_FILES_USING_SFIZZ

  726.             {

  727.                 CarlaPlugin::Initializer sfizzInitializer = {

  728.                     this,

  729.                     id,

  730.                     name,

  731.                     "",

  732.                     "http://sfztools.github.io/sfizz",

  733.                     0,

  734.                     options

  735.                 };

  736. 

  737.                 plugin = CarlaPlugin::newLV2(sfizzInitializer);

  738.             }

  739. # else

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

  741. # endif

  742.             break;

  743. 

  744.         case PLUGIN_JACK:

  745. # ifndef STATIC_PLUGIN_TARGET

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

  747. # else

  748.             setLastError("Static plugin target does not support JACK applications");

  749. # endif

  750.             break;

  751. #else

  752.         case PLUGIN_INTERNAL:

  753.         case PLUGIN_DLS:

  754.         case PLUGIN_GIG:

  755.         case PLUGIN_SF2:

  756.         case PLUGIN_SFZ:

  757.         case PLUGIN_JACK:

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

  759.             break;

  760. #endif

  761.         }

  762.     }

  763. 

  764.     if (plugin.get() == nullptr)

  765.         return false;

  766. 

  767.     plugin->reload();

  768. 

  769. #ifdef SFZ_FILES_USING_SFIZZ

  770.     if (ptype == PLUGIN_SFZ && plugin->getType() == PLUGIN_LV2)

  771.     {

  772.         plugin->setCustomData(LV2_ATOM__Path,

  773.                               "http://sfztools.github.io/sfizz:sfzfile",

  774.                               filename,

  775.                               false);

  776. 

  777.         plugin->restoreLV2State(true);

  778.     }

  779. #endif

  780. 

  781.     bool canRun = true;

  782. 

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

  784.     {

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

  786.         {

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

  788.             canRun = false;

  789.         }

  790.     }

  791. 

  792.     if (! canRun)

  793.     {

  794.         return false;

  795.     }

  796. 

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

  798.     pluginData.plugin = plugin;

  799.     carla_zeroFloats(pluginData.peaks, 4);

  800. 

  801. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  802.     if (oldPlugin.get() != nullptr)

  803.     {

  804.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  805. 

  806.         const ScopedThreadStopper sts(this);

  807. 

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

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

  810. 

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

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

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

  814. 

  815.         oldPlugin->prepareForDeletion();

  816.         pData->pluginsToDelete.push_back(oldPlugin);

  817. 

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

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

  820. 

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

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

  823. 

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

  825.         plugin->setEnabled(true);

  826. 

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

  828.     }

  829.     else if (! pData->loadingProject)

  830. #endif

  831.     {

  832.         plugin->setEnabled(true);

  833. 

  834.         ++pData->curPluginCount;

  835.         callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, id, plugin->getType(), 0, 0, 0.0f, plugin->getName());

  836. 

  837.         if (getType() != kEngineTypeBridge)

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

  839. 

  840. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  843. #endif

  844.     }

  845. 

  846.     return true;

  847. }

  848. 

  849. bool CarlaEngine::addPlugin(const PluginType ptype,

  850.                             const char* const filename,

  851.                             const char* const name,

  852.                             const char* const label,

  853.                             const int64_t uniqueId,

  854.                             const void* const extra)

  855. {

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

  857. }

  858. 

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

  860. {

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

  862. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  865. #else

  866.     CARLA_SAFE_ASSERT_RETURN_ERR(id == 0, "Invalid engine internal data");

  867. #endif

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

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

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

  871. 

  872.     const CarlaPluginPtr plugin = pData->plugins[id].plugin;

  873. 

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

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

  876. 

  877.     const ScopedThreadStopper sts(this);

  878. 

  879. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  882. 

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

  884. 

  885.     /*

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

  887.     {

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

  889.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  890.         plugin2->updateOscURL();

  891.     }

  892.     */

  893. #else

  894.     pData->curPluginCount = 0;

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

  896.     carla_zeroStruct(pData->plugins[0].peaks);

  897. #endif

  898. 

  899.     plugin->prepareForDeletion();

  900.     pData->pluginsToDelete.push_back(plugin);

  901. 

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

  903.     return true;

  904. }

  905. 

  906. bool CarlaEngine::removeAllPlugins()

  907. {

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

  909. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  912. #endif

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

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

  915. 

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

  917.         return true;

  918. 

  919.     const ScopedThreadStopper sts(this);

  920. 

  921.     const uint curPluginCount = pData->curPluginCount;

  922. 

  923. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  925.         pData->graph.removeAllPlugins();

  926. #endif

  927. 

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

  929. 

  930.     callback(true, false, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  931. 

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

  933.     {

  934.         const uint id = curPluginCount - i - 1;

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

  936. 

  937.         pluginData.plugin->prepareForDeletion();

  938.         pData->pluginsToDelete.push_back(pluginData.plugin);

  939. 

  940.         pluginData.plugin.reset();

  941.         carla_zeroStruct(pluginData.peaks);

  942. 

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

  944.         callback(true, false, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  945.     }

  946. 

  947.     return true;

  948. }

  949. 

  950. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  952. {

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

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

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

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

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

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

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

  960. 

  961.     const CarlaPluginPtr plugin = pData->plugins[id].plugin;

  962.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin.get() != nullptr, "Could not find plugin to rename");

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

  964. 

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

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

  967. 

  968.     plugin->setName(uniqueName);

  969. 

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

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

  972. 

  973.     callback(true, true, ENGINE_CALLBACK_PLUGIN_RENAMED, id, 0, 0, 0, 0.0f, uniqueName);

  974. 

  975.     delete[] uniqueName;

  976.     return true;

  977. }

  978. 

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

  980. {

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

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

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

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

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

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

  987. 

  988.     const CarlaPluginPtr plugin = pData->plugins[id].plugin;

  989. 

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

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

  992. 

  993.     char label[STR_MAX+1];

  994.     carla_zeroChars(label, STR_MAX+1);

  995. 

  996.     if (! plugin->getLabel(label))

  997.         label[0] = '\0';

  998. 

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

  1000. 

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

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

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

  1004.         return false;

  1005. 

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

  1007. 

  1008.     if (const CarlaPluginPtr newPlugin = pData->plugins[pluginCountBefore].plugin)

  1009.     {

  1010.         if (newPlugin->getType() == PLUGIN_LV2)

  1011.             newPlugin->cloneLV2Files(*plugin);

  1012.         newPlugin->loadStateSave(plugin->getStateSave(true));

  1013.     }

  1014. 

  1015.     return true;

  1016. }

  1017. 

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

  1019. {

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

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

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

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

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

  1025. 

  1026.     // might use this to reset

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

  1028.     {

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

  1030.         return true;

  1031.     }

  1032. 

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

  1034. 

  1035.     const CarlaPluginPtr plugin = pData->plugins[id].plugin;

  1036. 

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

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

  1039. 

  1040.     pData->nextPluginId = id;

  1041. 

  1042.     return true;

  1043. }

  1044. 

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

  1046. {

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

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

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

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

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

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

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

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

  1055. 

  1056.     const CarlaPluginPtr pluginA = pData->plugins[idA].plugin;

  1057.     const CarlaPluginPtr pluginB = pData->plugins[idB].plugin;

  1058. 

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

  1060.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginB.get() != nullptr, "Could not find plugin to switch");

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

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

  1063. 

  1064.     const ScopedThreadStopper sts(this);

  1065. 

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

  1067.         pData->graph.switchPlugins(pluginA, pluginB);

  1068. 

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

  1070. 

  1071.     // TODO

  1072.     /*

  1073.     pluginA->updateOscURL();

  1074.     pluginB->updateOscURL();

  1075. 

  1076.     if (isOscControlRegistered())

  1077.         oscSend_control_switch_plugins(idA, idB);

  1078.     */

  1079. 

  1080.     return true;

  1081. }

  1082. #endif

  1083. 

  1084. void CarlaEngine::touchPluginParameter(const uint, const uint32_t, const bool) noexcept

  1085. {

  1086. }

  1087. 

  1088. CarlaPluginPtr CarlaEngine::getPlugin(const uint id) const noexcept

  1089. {

  1090. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1093. #endif

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

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

  1096. 

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

  1098. }

  1099. 

  1100. CarlaPluginPtr CarlaEngine::getPluginUnchecked(const uint id) const noexcept

  1101. {

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

  1103. }

  1104. 

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

  1106. {

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

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

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

  1110. 

  1111.     CarlaString sname;

  1112.     sname = name;

  1113. 

  1114.     if (sname.isEmpty())

  1115.     {

  1116.         sname = "(No name)";

  1117.         return sname.dup();

  1118.     }

  1119. 

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

  1121. 

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

  1123.         return sname.dup();

  1124. 

  1125.     sname.truncate(maxNameSize);

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

  1127.     sname.replace('/', '.'); // '/' is used by us for client name prefix

  1128. 

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

  1130.     {

  1131.         const CarlaPluginPtr plugin = pData->plugins[i].plugin;

  1132.         CARLA_SAFE_ASSERT_BREAK(plugin.use_count() > 0);

  1133. 

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

  1135.         if (const char* const pluginName = plugin->getName())

  1136.         {

  1137.             if (sname != pluginName)

  1138.                 continue;

  1139.         }

  1140. 

  1141.         // Check if string has already been modified

  1142.         {

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

  1144. 

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

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

  1147.             {

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

  1149. 

  1150.                 if (number == 9)

  1151.                 {

  1152.                     // next number is 10, 2 digits

  1153.                     sname.truncate(len-4);

  1154.                     sname += " (10)";

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

  1156.                 }

  1157.                 else

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

  1159. 

  1160.                 continue;

  1161.             }

  1162. 

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

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

  1165.             {

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

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

  1168. 

  1169.                 if (n2 == '9')

  1170.                 {

  1171.                     n2 = '0';

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

  1173.                 }

  1174.                 else

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

  1176. 

  1177.                 sname[len-2] = n2;

  1178.                 sname[len-3] = n3;

  1179. 

  1180.                 continue;

  1181.             }

  1182.         }

  1183. 

  1184.         // Modify string if not

  1185.         sname += " (2)";

  1186.     }

  1187. 

  1188.     return sname.dup();

  1189. }

  1190. 

  1191. // -----------------------------------------------------------------------

  1192. // Project management

  1193. 

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

  1195. {

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

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

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

  1199. 

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

  1201.     File file(jfilename);

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

  1203. 

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

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

  1206. 

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

  1208. 

  1209.     // -------------------------------------------------------------------

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

  1211. 

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

  1213.         return loadProject(filename, false);

  1214. 

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

  1216. 

  1217.     if (extension == "dls")

  1218.         return addPlugin(PLUGIN_DLS, filename, baseName, baseName, 0, nullptr);

  1219. 

  1220.     if (extension == "gig")

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

  1222. 

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

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

  1225. 

  1226.     if (extension == "sfz")

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

  1228. 

  1229.     if (extension == "jsfx")

  1230.         return addPlugin(PLUGIN_JSFX, filename, baseName, baseName, 0, nullptr);

  1231. 

  1232.     // -------------------------------------------------------------------

  1233. 

  1234.     if (

  1235.         extension == "mp3"  ||

  1236. #ifdef HAVE_SNDFILE

  1237.         extension == "aif"  ||

  1238.         extension == "aifc" ||

  1239.         extension == "aiff" ||

  1240.         extension == "au"   ||

  1241.         extension == "bwf"  ||

  1242.         extension == "flac" ||

  1243.         extension == "htk"  ||

  1244.         extension == "iff"  ||

  1245.         extension == "mat4" ||

  1246.         extension == "mat5" ||

  1247.         extension == "oga"  ||

  1248.         extension == "ogg"  ||

  1249.         extension == "opus" ||

  1250.         extension == "paf"  ||

  1251.         extension == "pvf"  ||

  1252.         extension == "pvf5" ||

  1253.         extension == "sd2"  ||

  1254.         extension == "sf"   ||

  1255.         extension == "snd"  ||

  1256.         extension == "svx"  ||

  1257.         extension == "vcc"  ||

  1258.         extension == "w64"  ||

  1259.         extension == "wav"  ||

  1260.         extension == "xi"   ||

  1261. #endif

  1262. #ifdef HAVE_FFMPEG

  1263.         extension == "3g2" ||

  1264.         extension == "3gp" ||

  1265.         extension == "aac" ||

  1266.         extension == "ac3" ||

  1267.         extension == "amr" ||

  1268.         extension == "ape" ||

  1269.         extension == "mp2" ||

  1270.         extension == "mpc" ||

  1271.         extension == "wma" ||

  1272. # ifndef HAVE_SNDFILE

  1273.         // FFmpeg without sndfile

  1274.         extension == "flac" ||

  1275.         extension == "oga"  ||

  1276.         extension == "ogg"  ||

  1277.         extension == "w64"  ||

  1278.         extension == "wav"  ||

  1279. # endif

  1280. #endif

  1281.         false

  1282.        )

  1283.     {

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

  1285.         {

  1286.             if (const CarlaPluginPtr plugin = getPlugin(curPluginId))

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

  1288.             return true;

  1289.         }

  1290.         return false;

  1291.     }

  1292. 

  1293.     // -------------------------------------------------------------------

  1294. 

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

  1296.     {

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

  1298.         {

  1299.             if (const CarlaPluginPtr plugin = getPlugin(curPluginId))

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

  1301.             return true;

  1302.         }

  1303.         return false;

  1304.     }

  1305. 

  1306.     // -------------------------------------------------------------------

  1307.     // ZynAddSubFX

  1308. 

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

  1310.     {

  1311. #ifdef HAVE_ZYN_DEPS

  1312.         CarlaString nicerName("Zyn - ");

  1313. 

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

  1315. 

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

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

  1318.         else

  1319.             nicerName += baseName;

  1320. 

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

  1322.         {

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

  1324. 

  1325.             if (const CarlaPluginPtr plugin = getPlugin(curPluginId))

  1326.             {

  1327.                 const char* const ext = (extension == "xmz") ? "CarlaAlternateFile1" : "CarlaAlternateFile2";

  1328.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, ext, filename, true);

  1329.             }

  1330. 

  1331.             return true;

  1332.         }

  1333.         return false;

  1334. #else

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

  1336.         return false;

  1337. #endif

  1338.     }

  1339. 

  1340.     // -------------------------------------------------------------------

  1341.     // Direct plugin binaries

  1342. 

  1343. #ifdef CARLA_OS_MAC

  1344.     if (extension == "vst")

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

  1346. #else

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

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

  1349. #endif

  1350. 

  1351. #ifdef USING_JUCE

  1352.     if (extension == "vst3")

  1353.         return addPlugin(getBinaryTypeFromFile(filename), PLUGIN_VST3, filename, nullptr, nullptr, 0, nullptr);

  1354. #endif

  1355. 

  1356.     // -------------------------------------------------------------------

  1357. 

  1358.     setLastError("Unknown file extension");

  1359.     return false;

  1360. }

  1361. 

  1362. bool CarlaEngine::loadProject(const char* const filename, const bool setAsCurrentProject)

  1363. {

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

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

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

  1367. 

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

  1369.     const File file(jfilename);

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

  1371. 

  1372.     if (setAsCurrentProject)

  1373.     {

  1374. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1375.         if (pData->currentProjectFilename != filename)

  1376.         {

  1377.             pData->currentProjectFilename = filename;

  1378. 

  1379.             bool found;

  1380.             const size_t r = pData->currentProjectFilename.rfind(CARLA_OS_SEP, &found);

  1381. 

  1382.             if (found)

  1383.             {

  1384.                 pData->currentProjectFolder = filename;

  1385.                 pData->currentProjectFolder[r] = '\0';

  1386.             }

  1387.             else

  1388.             {

  1389.                 pData->currentProjectFolder.clear();

  1390.             }

  1391.         }

  1392. #endif

  1393.     }

  1394. 

  1395.     XmlDocument xml(file);

  1396.     return loadProjectInternal(xml, !setAsCurrentProject);

  1397. }

  1398. 

  1399. bool CarlaEngine::saveProject(const char* const filename, const bool setAsCurrentProject)

  1400. {

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

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

  1403. 

  1404.     if (setAsCurrentProject)

  1405.     {

  1406. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1407.         if (pData->currentProjectFilename != filename)

  1408.         {

  1409.             pData->currentProjectFilename = filename;

  1410. 

  1411.             bool found;

  1412.             const size_t r = pData->currentProjectFilename.rfind(CARLA_OS_SEP, &found);

  1413. 

  1414.             if (found)

  1415.             {

  1416.                 pData->currentProjectFolder = filename;

  1417.                 pData->currentProjectFolder[r] = '\0';

  1418.             }

  1419.             else

  1420.             {

  1421.                 pData->currentProjectFolder.clear();

  1422.             }

  1423.         }

  1424. #endif

  1425.     }

  1426. 

  1427.     MemoryOutputStream out;

  1428.     saveProjectInternal(out);

  1429. 

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

  1431.     File file(jfilename);

  1432. 

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

  1434.         return true;

  1435. 

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

  1437.     return false;

  1438. }

  1439. 

  1440. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1442. {

  1443.     return pData->currentProjectFolder.isNotEmpty() ? pData->currentProjectFolder.buffer()

  1444.                                                     : nullptr;

  1445. }

  1446. 

  1447. const char* CarlaEngine::getCurrentProjectFilename() const noexcept

  1448. {

  1449.     return pData->currentProjectFilename;

  1450. }

  1451. 

  1452. void CarlaEngine::clearCurrentProjectFilename() noexcept

  1453. {

  1454.     pData->currentProjectFilename.clear();

  1455.     pData->currentProjectFolder.clear();

  1456. }

  1457. #endif

  1458. 

  1459. // -----------------------------------------------------------------------

  1460. // Information (base)

  1461. 

  1462. uint32_t CarlaEngine::getBufferSize() const noexcept

  1463. {

  1464.     return pData->bufferSize;

  1465. }

  1466. 

  1467. double CarlaEngine::getSampleRate() const noexcept

  1468. {

  1469.     return pData->sampleRate;

  1470. }

  1471. 

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

  1473. {

  1474.     return pData->name;

  1475. }

  1476. 

  1477. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1478. {

  1479.     return pData->options.processMode;

  1480. }

  1481. 

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

  1483. {

  1484.     return pData->options;

  1485. }

  1486. 

  1487. EngineTimeInfo CarlaEngine::getTimeInfo() const noexcept

  1488. {

  1489.     return pData->timeInfo;

  1490. }

  1491. 

  1492. // -----------------------------------------------------------------------

  1493. // Information (peaks)

  1494. 

  1495. const float* CarlaEngine::getPeaks(const uint pluginId) const noexcept

  1496. {

  1497.     static const float kFallback[4] = { 0.0f, 0.0f, 0.0f, 0.0f };

  1498. 

  1499.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1500.     {

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

  1502.         if (const uint count = pData->curPluginCount)

  1503.         {

  1504.             pData->peaks[0] = pData->plugins[0].peaks[0];

  1505.             pData->peaks[1] = pData->plugins[0].peaks[1];

  1506.             pData->peaks[2] = pData->plugins[count-1].peaks[2];

  1507.             pData->peaks[3] = pData->plugins[count-1].peaks[3];

  1508.         }

  1509.         else

  1510.         {

  1511.             carla_zeroFloats(pData->peaks, 4);

  1512.         }

  1513. 

  1514.         return pData->peaks;

  1515.     }

  1516. 

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

  1518. 

  1519.     return pData->plugins[pluginId].peaks;

  1520. }

  1521. 

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

  1523. {

  1524.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1525.     {

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

  1527.         if (pData->curPluginCount > 0)

  1528.             return pData->plugins[0].peaks[isLeft ? 0 : 1];

  1529.         return 0.0f;

  1530.     }

  1531. 

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

  1533. 

  1534.     return pData->plugins[pluginId].peaks[isLeft ? 0 : 1];

  1535. }

  1536. 

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

  1538. {

  1539.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1540.     {

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

  1542.         if (pData->curPluginCount > 0)

  1543.             return pData->plugins[pData->curPluginCount-1].peaks[isLeft ? 2 : 3];

  1544.         return 0.0f;

  1545.     }

  1546. 

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

  1548. 

  1549.     return pData->plugins[pluginId].peaks[isLeft ? 2 : 3];

  1550. }

  1551. 

  1552. // -----------------------------------------------------------------------

  1553. // Callback

  1554. 

  1555. void CarlaEngine::callback(const bool sendHost, const bool sendOSC,

  1556.                            const EngineCallbackOpcode action, const uint pluginId,

  1557.                            const int value1, const int value2, const int value3,

  1558.                            const float valuef, const char* const valueStr) noexcept

  1559. {

  1560. #ifdef DEBUG

  1561.     if (pData->isIdling)

  1562.         carla_stdout("CarlaEngine::callback [while idling] (%s, %s, %i:%s, %i, %i, %i, %i, %f, \"%s\")",

  1563.                      bool2str(sendHost), bool2str(sendOSC),

  1564.                      action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3,

  1565.                      static_cast<double>(valuef), valueStr);

  1566.     else if (action != ENGINE_CALLBACK_IDLE && action != ENGINE_CALLBACK_NOTE_ON && action != ENGINE_CALLBACK_NOTE_OFF)

  1567.         carla_debug("CarlaEngine::callback(%s, %s, %i:%s, %i, %i, %i, %i, %f, \"%s\")",

  1568.                     bool2str(sendHost), bool2str(sendOSC),

  1569.                     action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3,

  1570.                     static_cast<double>(valuef), valueStr);

  1571. #endif

  1572. 

  1573.     if (sendHost && pData->callback != nullptr)

  1574.     {

  1575.         if (action == ENGINE_CALLBACK_IDLE)

  1576.             ++pData->isIdling;

  1577. 

  1578.         try {

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

  1580.         } CARLA_SAFE_EXCEPTION("callback")

  1581. 

  1582.         if (action == ENGINE_CALLBACK_IDLE)

  1583.             --pData->isIdling;

  1584.     }

  1585. 

  1586.     if (sendOSC)

  1587.     {

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

  1589.         if (pData->osc.isControlRegisteredForTCP())

  1590.         {

  1591.             switch (action)

  1592.             {

  1593.             case ENGINE_CALLBACK_RELOAD_INFO:

  1594.             {

  1595.                 CarlaPluginPtr plugin = pData->plugins[pluginId].plugin;

  1596.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1597. 

  1598.                 pData->osc.sendPluginInfo(plugin);

  1599.                 break;

  1600.             }

  1601. 

  1602.             case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  1603.             {

  1604.                 CarlaPluginPtr plugin = pData->plugins[pluginId].plugin;

  1605.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1606. 

  1607.                 pData->osc.sendPluginPortCount(plugin);

  1608. 

  1609.                 if (const uint32_t count = plugin->getParameterCount())

  1610.                 {

  1611.                     for (uint32_t i=0; i<count; ++i)

  1612.                       pData->osc.sendPluginParameterInfo(plugin, i);

  1613.                 }

  1614.                 break;

  1615.             }

  1616. 

  1617.             case ENGINE_CALLBACK_RELOAD_PROGRAMS:

  1618.             {

  1619.                 CarlaPluginPtr plugin = pData->plugins[pluginId].plugin;

  1620.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1621. 

  1622.                 pData->osc.sendPluginProgramCount(plugin);

  1623. 

  1624.                 if (const uint32_t count = plugin->getProgramCount())

  1625.                 {

  1626.                     for (uint32_t i=0; i<count; ++i)

  1627.                       pData->osc.sendPluginProgram(plugin, i);

  1628.                 }

  1629. 

  1630.                 if (const uint32_t count = plugin->getMidiProgramCount())

  1631.                 {

  1632.                     for (uint32_t i=0; i<count; ++i)

  1633.                       pData->osc.sendPluginMidiProgram(plugin, i);

  1634.                 }

  1635.                 break;

  1636.             }

  1637. 

  1638.             case ENGINE_CALLBACK_PLUGIN_ADDED:

  1639.             case ENGINE_CALLBACK_RELOAD_ALL:

  1640.             {

  1641.                 CarlaPluginPtr plugin = pData->plugins[pluginId].plugin;

  1642.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1643. 

  1644.                 pData->osc.sendPluginInfo(plugin);

  1645.                 pData->osc.sendPluginPortCount(plugin);

  1646.                 pData->osc.sendPluginDataCount(plugin);

  1647. 

  1648.                 if (const uint32_t count = plugin->getParameterCount())

  1649.                 {

  1650.                     for (uint32_t i=0; i<count; ++i)

  1651.                       pData->osc.sendPluginParameterInfo(plugin, i);

  1652.                 }

  1653. 

  1654.                 if (const uint32_t count = plugin->getProgramCount())

  1655.                 {

  1656.                     for (uint32_t i=0; i<count; ++i)

  1657.                       pData->osc.sendPluginProgram(plugin, i);

  1658.                 }

  1659. 

  1660.                 if (const uint32_t count = plugin->getMidiProgramCount())

  1661.                 {

  1662.                     for (uint32_t i=0; i<count; ++i)

  1663.                       pData->osc.sendPluginMidiProgram(plugin, i);

  1664.                 }

  1665. 

  1666.                 if (const uint32_t count = plugin->getCustomDataCount())

  1667.                 {

  1668.                     for (uint32_t i=0; i<count; ++i)

  1669.                       pData->osc.sendPluginCustomData(plugin, i);

  1670.                 }

  1671. 

  1672.                 pData->osc.sendPluginInternalParameterValues(plugin);

  1673.                 break;

  1674.             }

  1675. 

  1676.             case ENGINE_CALLBACK_IDLE:

  1677.                 return;

  1678. 

  1679.             default:

  1680.                 break;

  1681.             }

  1682. 

  1683.             pData->osc.sendCallback(action, pluginId, value1, value2, value3, valuef, valueStr);

  1684.         }

  1685. #endif

  1686.     }

  1687. }

  1688. 

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

  1690. {

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

  1692. 

  1693.     pData->callback    = func;

  1694.     pData->callbackPtr = ptr;

  1695. }

  1696. 

  1697. // -----------------------------------------------------------------------

  1698. // File Callback

  1699. 

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

  1701. {

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

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

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

  1705. 

  1706.     const char* ret = nullptr;

  1707. 

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

  1709.     {

  1710.         try {

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

  1712.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1713.     }

  1714. 

  1715.     return ret;

  1716. }

  1717. 

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

  1719. {

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

  1721. 

  1722.     pData->fileCallback    = func;

  1723.     pData->fileCallbackPtr = ptr;

  1724. }

  1725. 

  1726. // -----------------------------------------------------------------------

  1727. // Transport

  1728. 

  1729. void CarlaEngine::transportPlay() noexcept

  1730. {

  1731.     pData->timeInfo.playing = true;

  1732.     pData->time.setNeedsReset();

  1733. }

  1734. 

  1735. void CarlaEngine::transportPause() noexcept

  1736. {

  1737.     if (pData->timeInfo.playing)

  1738.         pData->time.pause();

  1739.     else

  1740.         pData->time.setNeedsReset();

  1741. }

  1742. 

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

  1744. {

  1745.     CARLA_SAFE_ASSERT_RETURN(bpm >= 20.0,)

  1746. 

  1747.     try {

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

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

  1750. }

  1751. 

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

  1753. {

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

  1755. }

  1756. 

  1757. // -----------------------------------------------------------------------

  1758. // Error handling

  1759. 

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

  1761. {

  1762.     return pData->lastError;

  1763. }

  1764. 

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

  1766. {

  1767.     pData->lastError = error;

  1768. }

  1769. 

  1770. // -----------------------------------------------------------------------

  1771. // Misc

  1772. 

  1773. bool CarlaEngine::isAboutToClose() const noexcept

  1774. {

  1775.     return pData->aboutToClose;

  1776. }

  1777. 

  1778. bool CarlaEngine::setAboutToClose() noexcept

  1779. {

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

  1781. 

  1782.     pData->aboutToClose = true;

  1783. 

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

  1785. }

  1786. 

  1787. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1788. bool CarlaEngine::isLoadingProject() const noexcept

  1789. {

  1790.     return pData->loadingProject;

  1791. }

  1792. #endif

  1793. 

  1794. void CarlaEngine::setActionCanceled(const bool canceled) noexcept

  1795. {

  1796.     pData->actionCanceled = canceled;

  1797. }

  1798. 

  1799. bool CarlaEngine::wasActionCanceled() const noexcept

  1800. {

  1801.     return pData->actionCanceled;

  1802. }

  1803. 

  1804. // -----------------------------------------------------------------------

  1805. // Global options

  1806. 

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

  1808. {

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

  1810. 

  1811.     if (isRunning())

  1812.     {

  1813.         switch (option)

  1814.         {

  1815.         case ENGINE_OPTION_PROCESS_MODE:

  1816.         case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

  1817.         case ENGINE_OPTION_AUDIO_DRIVER:

  1818.         case ENGINE_OPTION_AUDIO_DEVICE:

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

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

  1821.         default:

  1822.             break;

  1823.         }

  1824.     }

  1825. 

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

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

  1828.         return;

  1829. 

  1830.     switch (option)

  1831.     {

  1832.     case ENGINE_OPTION_DEBUG:

  1833.         break;

  1834. 

  1835.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1838.         break;

  1839. 

  1840.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

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

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

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

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

  1847.         else

  1848.             pData->options.transportExtra = nullptr;

  1849. 

  1850.         pData->time.setNeedsReset();

  1851. 

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

  1853.         // enable link now if needed

  1854.         {

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

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

  1857.         }

  1858. #endif

  1859.         break;

  1860. 

  1861.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1864.         break;

  1865. 

  1866.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1867. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1868.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1869. #else

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

  1871. #endif

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

  1873.         break;

  1874. 

  1875.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1878.         break;

  1879. 

  1880.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1883.         break;

  1884. 

  1885.     case ENGINE_OPTION_MAX_PARAMETERS:

  1886.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1888.         break;

  1889. 

  1890.     case ENGINE_OPTION_RESET_XRUNS:

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

  1892.         pData->options.resetXruns = (value != 0);

  1893.         break;

  1894. 

  1895.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1896.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1898.         break;

  1899. 

  1900.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1901.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1903.         break;

  1904. 

  1905.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1906.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1908.         break;

  1909. 

  1910.     case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  1913.         break;

  1914. 

  1915.     case ENGINE_OPTION_AUDIO_DRIVER:

  1916.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1917. 

  1918.         if (pData->options.audioDriver != nullptr)

  1919.             delete[] pData->options.audioDriver;

  1920. 

  1921.         pData->options.audioDriver = carla_strdup_safe(valueStr);

  1922.         break;

  1923. 

  1924.     case ENGINE_OPTION_AUDIO_DEVICE:

  1925.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1926. 

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

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

  1929. 

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

  1931.         break;

  1932. 

  1933. #ifndef BUILD_BRIDGE

  1934.     case ENGINE_OPTION_OSC_ENABLED:

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

  1936.         pData->options.oscEnabled = (value != 0);

  1937.         break;

  1938. 

  1939.     case ENGINE_OPTION_OSC_PORT_TCP:

  1940.         CARLA_SAFE_ASSERT_RETURN(value <= 0 || value >= 1024,);

  1941.         pData->options.oscPortTCP = value;

  1942.         break;

  1943. 

  1944.     case ENGINE_OPTION_OSC_PORT_UDP:

  1945.         CARLA_SAFE_ASSERT_RETURN(value <= 0 || value >= 1024,);

  1946.         pData->options.oscPortUDP = value;

  1947.         break;

  1948. #endif

  1949. 

  1950.     case ENGINE_OPTION_FILE_PATH:

  1951.         CARLA_SAFE_ASSERT_RETURN(value > FILE_NONE,);

  1952.         CARLA_SAFE_ASSERT_RETURN(value <= FILE_MIDI,);

  1953. 

  1954.         switch (value)

  1955.         {

  1956.         case FILE_AUDIO:

  1957.             if (pData->options.pathAudio != nullptr)

  1958.                 delete[] pData->options.pathAudio;

  1959.             if (valueStr != nullptr)

  1960.                 pData->options.pathAudio = carla_strdup_safe(valueStr);

  1961.             else

  1962.                 pData->options.pathAudio = nullptr;

  1963.             break;

  1964.         case FILE_MIDI:

  1965.             if (pData->options.pathMIDI != nullptr)

  1966.                 delete[] pData->options.pathMIDI;

  1967.             if (valueStr != nullptr)

  1968.                 pData->options.pathMIDI = carla_strdup_safe(valueStr);

  1969.             else

  1970.                 pData->options.pathMIDI = nullptr;

  1971.             break;

  1972.         default:

  1973.             return carla_stderr("CarlaEngine::setOption(%i:%s, %i, \"%s\") - Invalid file type",

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

  1975.             break;

  1976.         }

  1977.         break;

  1978.     case ENGINE_OPTION_PLUGIN_PATH:

  1979.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1980.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_JSFX,);

  1981. 

  1982.         switch (value)

  1983.         {

  1984.         case PLUGIN_LADSPA:

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

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

  1987.             if (valueStr != nullptr)

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

  1989.             else

  1990.                 pData->options.pathLADSPA = nullptr;

  1991.             break;

  1992.         case PLUGIN_DSSI:

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

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

  1995.             if (valueStr != nullptr)

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

  1997.             else

  1998.                 pData->options.pathDSSI = nullptr;

  1999.             break;

  2000.         case PLUGIN_LV2:

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

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

  2003.             if (valueStr != nullptr)

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

  2005.             else

  2006.                 pData->options.pathLV2 = nullptr;

  2007.             break;

  2008.         case PLUGIN_VST2:

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

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

  2011.             if (valueStr != nullptr)

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

  2013.             else

  2014.                 pData->options.pathVST2 = nullptr;

  2015.             break;

  2016.         case PLUGIN_VST3:

  2017.             if (pData->options.pathVST3 != nullptr)

  2018.                 delete[] pData->options.pathVST3;

  2019.             if (valueStr != nullptr)

  2020.                 pData->options.pathVST3 = carla_strdup_safe(valueStr);

  2021.             else

  2022.                 pData->options.pathVST3 = nullptr;

  2023.             break;

  2024.         case PLUGIN_SF2:

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

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

  2027.             if (valueStr != nullptr)

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

  2029.             else

  2030.                 pData->options.pathSF2 = nullptr;

  2031.             break;

  2032.         case PLUGIN_SFZ:

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

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

  2035.             if (valueStr != nullptr)

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

  2037.             else

  2038.                 pData->options.pathSFZ = nullptr;

  2039.             break;

  2040.         case PLUGIN_JSFX:

  2041.             if (pData->options.pathJSFX != nullptr)

  2042.                 delete[] pData->options.pathJSFX;

  2043.             if (valueStr != nullptr)

  2044.                 pData->options.pathJSFX = carla_strdup_safe(valueStr);

  2045.             else

  2046.                 pData->options.pathJSFX = nullptr;

  2047.             break;

  2048.         default:

  2049.             return carla_stderr("CarlaEngine::setOption(%i:%s, %i, \"%s\") - Invalid plugin type",

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

  2051.             break;

  2052.         }

  2053.         break;

  2054. 

  2055.     case ENGINE_OPTION_PATH_BINARIES:

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

  2057. 

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

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

  2060. 

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

  2062.         break;

  2063. 

  2064.     case ENGINE_OPTION_PATH_RESOURCES:

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

  2066. 

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

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

  2069. 

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

  2071.         break;

  2072. 

  2073.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR: {

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

  2075. 

  2076. #ifdef CARLA_OS_LINUX

  2077.         const ScopedEngineEnvironmentLocker _seel(this);

  2078. 

  2079.         if (value != 0)

  2080.         {

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

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

  2083.         }

  2084.         else

  2085.         {

  2086.             ::unsetenv("LD_PRELOAD");

  2087.         }

  2088. #endif

  2089.     }   break;

  2090. 

  2091.     case ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

  2092.         pData->options.bgColor = static_cast<uint>(value);

  2093.         break;

  2094. 

  2095.     case ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

  2096.         pData->options.fgColor = static_cast<uint>(value);

  2097.         break;

  2098. 

  2099.     case ENGINE_OPTION_FRONTEND_UI_SCALE:

  2100.         CARLA_SAFE_ASSERT_RETURN(value > 0,);

  2101.         pData->options.uiScale = static_cast<float>(value) / 1000;

  2102.         break;

  2103. 

  2104.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  2107.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  2109.     }   break;

  2110. 

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

  2112.     case ENGINE_OPTION_WINE_EXECUTABLE:

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

  2114. 

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

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

  2117. 

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

  2119.         break;

  2120. 

  2121.     case ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  2124.         break;

  2125. 

  2126.     case ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  2128. 

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

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

  2131. 

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

  2133.         break;

  2134. 

  2135.     case ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  2138.         break;

  2139. 

  2140.     case ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  2143.         break;

  2144. 

  2145.     case ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  2148.         break;

  2149. #endif

  2150. 

  2151. #ifndef BUILD_BRIDGE

  2152.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  2153.         break;

  2154. #endif

  2155. 

  2156.     case ENGINE_OPTION_CLIENT_NAME_PREFIX:

  2157.         if (pData->options.clientNamePrefix != nullptr)

  2158.             delete[] pData->options.clientNamePrefix;

  2159. 

  2160.         pData->options.clientNamePrefix = valueStr != nullptr && valueStr[0] != '\0'

  2161.                                         ? carla_strdup_safe(valueStr)

  2162.                                         : nullptr;

  2163.         break;

  2164. 

  2165.     case ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

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

  2167.         pData->options.pluginsAreStandalone = (value != 0);

  2168.         break;

  2169.     }

  2170. }

  2171. 

  2172. #ifndef BUILD_BRIDGE

  2173. // -----------------------------------------------------------------------

  2174. // OSC Stuff

  2175. 

  2176. bool CarlaEngine::isOscControlRegistered() const noexcept

  2177. {

  2178. # ifdef HAVE_LIBLO

  2179.     return pData->osc.isControlRegisteredForTCP();

  2180. # else

  2181.     return false;

  2182. # endif

  2183. }

  2184. 

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

  2186. {

  2187. # ifdef HAVE_LIBLO

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

  2189. # else

  2190.     return nullptr;

  2191. # endif

  2192. }

  2193. 

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

  2195. {

  2196. # ifdef HAVE_LIBLO

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

  2198. # else

  2199.     return nullptr;

  2200. # endif

  2201. }

  2202. #endif

  2203. 

  2204. // -----------------------------------------------------------------------

  2205. // Internal stuff

  2206. 

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

  2208. {

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

  2210. 

  2211. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2214.     {

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

  2216.     }

  2217. #endif

  2218. 

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

  2220. 

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

  2222.     {

  2223.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2224.         {

  2225.             if (plugin->isEnabled() && plugin->tryLock(true))

  2226.             {

  2227.                 plugin->bufferSizeChanged(newBufferSize);

  2228.                 plugin->unlock();

  2229.             }

  2230.         }

  2231.     }

  2232. 

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

  2234. }

  2235. 

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

  2237. {

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

  2239. 

  2240. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2243.     {

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

  2245.     }

  2246. #endif

  2247. 

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

  2249. 

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

  2251.     {

  2252.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2253.         {

  2254.             if (plugin->isEnabled() && plugin->tryLock(true))

  2255.             {

  2256.                 plugin->sampleRateChanged(newSampleRate);

  2257.                 plugin->unlock();

  2258.             }

  2259.         }

  2260.     }

  2261. 

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

  2263. }

  2264. 

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

  2266. {

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

  2268. 

  2269. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2272.     {

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

  2274.     }

  2275. #endif

  2276. 

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

  2278.     {

  2279.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2280.             if (plugin->isEnabled())

  2281.                 plugin->offlineModeChanged(isOfflineNow);

  2282.     }

  2283. }

  2284. 

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

  2286. {

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

  2288. 

  2289.     pluginData.peaks[0]  = inPeaks[0];

  2290.     pluginData.peaks[1]  = inPeaks[1];

  2291.     pluginData.peaks[2] = outPeaks[0];

  2292.     pluginData.peaks[3] = outPeaks[1];

  2293. }

  2294. 

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

  2296. {

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

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

  2299.     {

  2300.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2301.         {

  2302.             if (plugin->isEnabled())

  2303.             {

  2304. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

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

  2308. #endif

  2309.                 plugin->prepareForSave(false);

  2310.             }

  2311.         }

  2312.     }

  2313. 

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

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

  2316.     outStream << "<CARLA-PROJECT VERSION='" CARLA_VERSION_STRMIN "'";

  2317. 

  2318. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2319.     if (pData->ignoreClientPrefix)

  2320.         outStream << " IgnoreClientPrefix='true'";

  2321. #endif

  2322. 

  2323.     outStream << ">\n";

  2324. 

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

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

  2327. 

  2328.     {

  2329.         MemoryOutputStream outSettings(1024);

  2330. 

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

  2332. 

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

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

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

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

  2337. 

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

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

  2340. 

  2341.         if (isPlugin)

  2342.         {

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

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

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

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

  2347.             outSettings << "  <VST3_PATH>"   << xmlSafeString(options.pathVST3,   true) << "</VST3_PATH>\n";

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

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

  2350.             outSettings << "  <JSFX_PATH>"   << xmlSafeString(options.pathJSFX,   true) << "</JSFX_PATH>\n";

  2351.         }

  2352. 

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

  2354.         outStream << outSettings;

  2355.     }

  2356. 

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

  2358.     {

  2359.         MemoryOutputStream outTransport(128);

  2360. 

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

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

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

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

  2365.         outStream << outTransport;

  2366.     }

  2367. 

  2368.     char strBuf[STR_MAX+1];

  2369.     carla_zeroChars(strBuf, STR_MAX+1);

  2370. 

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

  2372.     {

  2373.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2374.         {

  2375.             if (plugin->isEnabled())

  2376.             {

  2377.                 MemoryOutputStream outPlugin(4096), streamPlugin;

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

  2379. 

  2380.                 outPlugin << "\n";

  2381. 

  2382.                 if (plugin->getRealName(strBuf))

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

  2384. 

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

  2386.                 outPlugin << streamPlugin;

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

  2388.                 outStream << outPlugin;

  2389.             }

  2390.         }

  2391.     }

  2392. 

  2393. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2394.     // tell bridges we're done saving

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

  2396.     {

  2397.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

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

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

  2400.     }

  2401. 

  2402.     // save internal connections

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

  2404.     {

  2405.         uint posCount = 0;

  2406.         const char* const* const patchbayConns = getPatchbayConnections(false);

  2407.         const PatchbayPosition* const patchbayPos = getPatchbayPositions(false, posCount);

  2408. 

  2409.         if (patchbayConns != nullptr || patchbayPos != nullptr)

  2410.         {

  2411.             MemoryOutputStream outPatchbay(2048);

  2412. 

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

  2414. 

  2415.             if (patchbayConns != nullptr)

  2416.             {

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

  2418.                 {

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

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

  2421. 

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

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

  2424. 

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

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

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

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

  2429.                 }

  2430.             }

  2431. 

  2432.             if (patchbayPos != nullptr && posCount != 0)

  2433.             {

  2434.                 outPatchbay << "  <Positions>\n";

  2435. 

  2436.                 for (uint i=0; i<posCount; ++i)

  2437.                 {

  2438.                     const PatchbayPosition& ppos(patchbayPos[i]);

  2439. 

  2440.                     CARLA_SAFE_ASSERT_CONTINUE(ppos.name != nullptr && ppos.name[0] != '\0');

  2441. 

  2442.                     outPatchbay << "   <Position x1=\"" << ppos.x1 << "\" y1=\"" << ppos.y1;

  2443.                     if (ppos.x2 != 0 || ppos.y2 != 0)

  2444.                         outPatchbay << "\" x2=\"" << ppos.x2 << "\" y2=\"" << ppos.y2;

  2445.                     if (ppos.pluginId >= 0)

  2446.                         outPatchbay << "\" pluginId=\"" << ppos.pluginId;

  2447.                     outPatchbay << "\">\n";

  2448.                     outPatchbay << "    <Name>" << xmlSafeString(ppos.name, true) << "</Name>\n";

  2449.                     outPatchbay << "   </Position>\n";

  2450. 

  2451.                     if (ppos.dealloc)

  2452.                         delete[] ppos.name;

  2453.                 }

  2454. 

  2455.                 outPatchbay << "  </Positions>\n";

  2456.             }

  2457. 

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

  2459.             outStream << outPatchbay;

  2460. 

  2461.             delete[] patchbayPos;

  2462.         }

  2463. 

  2464.     }

  2465. 

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

  2467.     bool saveExternalConnections, saveExternalPositions = true;

  2468. 

  2469.     /**/ if (isPlugin)

  2470.     {

  2471.         saveExternalConnections = false;

  2472.         saveExternalPositions = false;

  2473.     }

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

  2475.     {

  2476.         saveExternalConnections = true;

  2477.     }

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

  2479.     {

  2480.         saveExternalConnections = false;

  2481.     }

  2482.     else

  2483.     {

  2484.         saveExternalConnections = true;

  2485.     }

  2486. 

  2487.     if (saveExternalConnections || saveExternalPositions)

  2488.     {

  2489.         uint posCount = 0;

  2490.         const char* const* const patchbayConns = saveExternalConnections

  2491.                                                ? getPatchbayConnections(true)

  2492.                                                : nullptr;

  2493.         const PatchbayPosition* const patchbayPos = saveExternalPositions

  2494.                                                   ? getPatchbayPositions(true, posCount)

  2495.                                                   : nullptr;

  2496. 

  2497.         if (patchbayConns != nullptr || patchbayPos != nullptr)

  2498.         {

  2499.             MemoryOutputStream outPatchbay(2048);

  2500. 

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

  2502. 

  2503.             if (patchbayConns != nullptr)

  2504.             {

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

  2506.                 {

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

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

  2509. 

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

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

  2512. 

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

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

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

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

  2517.                 }

  2518.             }

  2519. 

  2520.             if (patchbayPos != nullptr && posCount != 0)

  2521.             {

  2522.                 outPatchbay << "  <Positions>\n";

  2523. 

  2524.                 for (uint i=0; i<posCount; ++i)

  2525.                 {

  2526.                     const PatchbayPosition& ppos(patchbayPos[i]);

  2527. 

  2528.                     CARLA_SAFE_ASSERT_CONTINUE(ppos.name != nullptr && ppos.name[0] != '\0');

  2529. 

  2530.                     outPatchbay << "   <Position x1=\"" << ppos.x1 << "\" y1=\"" << ppos.y1;

  2531.                     if (ppos.x2 != 0 || ppos.y2 != 0)

  2532.                         outPatchbay << "\" x2=\"" << ppos.x2 << "\" y2=\"" << ppos.y2;

  2533.                     if (ppos.pluginId >= 0)

  2534.                         outPatchbay << "\" pluginId=\"" << ppos.pluginId;

  2535.                     outPatchbay << "\">\n";

  2536.                     outPatchbay << "    <Name>" << xmlSafeString(ppos.name, true) << "</Name>\n";

  2537.                     outPatchbay << "   </Position>\n";

  2538. 

  2539.                     if (ppos.dealloc)

  2540.                         delete[] ppos.name;

  2541.                 }

  2542. 

  2543.                 outPatchbay << "  </Positions>\n";

  2544.             }

  2545. 

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

  2547.             outStream << outPatchbay;

  2548.         }

  2549.     }

  2550. #endif

  2551. 

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

  2553. }

  2554. 

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

  2556. {

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

  2558. 

  2559.     // try direct filename first

  2560.     String jbinary(binary);

  2561. 

  2562.     // adjust for current platform

  2563. #ifdef CARLA_OS_WIN

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

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

  2566. #else

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

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

  2569. #endif

  2570. 

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

  2572. 

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

  2574. 

  2575.     if (filename.endsWithIgnoreCase(".vst3"))

  2576.         searchFlags |= File::findDirectories;

  2577. #ifdef CARLA_OS_MAC

  2578.     else if (filename.endsWithIgnoreCase(".vst"))

  2579.         searchFlags |= File::findDirectories;

  2580. #endif

  2581. 

  2582.     std::vector<File> results;

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

  2584.     {

  2585.         const File path(*it);

  2586. 

  2587.         results.clear();

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

  2589. 

  2590.         if (!results.empty())

  2591.             return results.front().getFullPathName();

  2592.     }

  2593. 

  2594.     // try changing extension

  2595. #if defined(CARLA_OS_MAC)

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

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

  2598. #elif defined(CARLA_OS_WIN)

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

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

  2601. #else

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

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

  2604. #endif

  2605.     else

  2606.         return String();

  2607. 

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

  2609.     {

  2610.         const File path(*it);

  2611. 

  2612.         results.clear();

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

  2614. 

  2615.         if (!results.empty())

  2616.             return results.front().getFullPathName();

  2617.     }

  2618. 

  2619.     return String();

  2620. }

  2621. 

  2622. bool CarlaEngine::loadProjectInternal(water::XmlDocument& xmlDoc, const bool alwaysLoadConnections)

  2623. {

  2624.     carla_debug("CarlaEngine::loadProjectInternal(%p, %s) - START", &xmlDoc, bool2str(alwaysLoadConnections));

  2625. 

  2626.     CarlaScopedPointer<XmlElement> xmlElement(xmlDoc.getDocumentElement(true));

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

  2628. 

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

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

  2631. 

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

  2633.     {

  2634.         callback(true, true, ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

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

  2636.         return false;

  2637.     }

  2638. 

  2639.     pData->actionCanceled = false;

  2640.     callback(true, true, ENGINE_CALLBACK_CANCELABLE_ACTION, 0, 1, 0, 0, 0.0f, "Loading project");

  2641. 

  2642. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2643.     if (pData->options.clientNamePrefix != nullptr)

  2644.     {

  2645.         if (carla_isEqual(xmlElement->getDoubleAttribute("VERSION", 0.0), 2.0) ||

  2646.             xmlElement->getBoolAttribute("IgnoreClientPrefix", false))

  2647.         {

  2648.             carla_stdout("Loading project in compatibility mode, will ignore client name prefix");

  2649.             pData->ignoreClientPrefix = true;

  2650.             setOption(ENGINE_OPTION_CLIENT_NAME_PREFIX, 0, "");

  2651.         }

  2652.     }

  2653. 

  2654.     const CarlaScopedValueSetter<bool> csvs(pData->loadingProject, true, false);

  2655. #endif

  2656. 

  2657.     // completely load file

  2658.     xmlElement = xmlDoc.getDocumentElement(false);

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

  2660. 

  2661.     if (pData->aboutToClose)

  2662.         return true;

  2663. 

  2664.     if (pData->actionCanceled)

  2665.     {

  2666.         setLastError("Project load canceled");

  2667.         return false;

  2668.     }

  2669. 

  2670.     callback(true, false, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  2671. 

  2672. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2673.     const bool isMultiClient = pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS;

  2674.     const bool isPatchbay    = pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY;

  2675. #endif

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

  2677. 

  2678.     // load engine settings first of all

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

  2680.     {

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

  2682.         {

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

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

  2685. 

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

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

  2688. 

  2689.             int option = -1;

  2690.             int value  = 0;

  2691.             const char* valueStr = nullptr;

  2692. 

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

  2694.             {

  2695.                 option = ENGINE_OPTION_FORCE_STEREO;

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

  2697.             }

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

  2699.             {

  2700.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

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

  2702.             }

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

  2704.             {

  2705.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

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

  2707.             }

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

  2709.             {

  2710.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

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

  2712.             }

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

  2714.             {

  2715.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2716.                 value  = text.getIntValue();

  2717.             }

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

  2719.             {

  2720.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2721.                 value  = text.getIntValue();

  2722.             }

  2723.             else if (isPlugin)

  2724.             {

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

  2726.                 {

  2727.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2728.                     value    = PLUGIN_LADSPA;

  2729.                     valueStr = text.toRawUTF8();

  2730.                 }

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

  2732.                 {

  2733.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2734.                     value    = PLUGIN_DSSI;

  2735.                     valueStr = text.toRawUTF8();

  2736.                 }

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

  2738.                 {

  2739.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2740.                     value    = PLUGIN_LV2;

  2741.                     valueStr = text.toRawUTF8();

  2742.                 }

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

  2744.                 {

  2745.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2746.                     value    = PLUGIN_VST2;

  2747.                     valueStr = text.toRawUTF8();

  2748.                 }

  2749.                 else if (tag.equalsIgnoreCase("VST3_PATH"))

  2750.                 {

  2751.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2752.                     value    = PLUGIN_VST3;

  2753.                     valueStr = text.toRawUTF8();

  2754.                 }

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

  2756.                 {

  2757.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2758.                     value    = PLUGIN_SF2;

  2759.                     valueStr = text.toRawUTF8();

  2760.                 }

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

  2762.                 {

  2763.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2764.                     value    = PLUGIN_SFZ;

  2765.                     valueStr = text.toRawUTF8();

  2766.                 }

  2767.                 else if (tag == "JSFX_PATH")

  2768.                 {

  2769.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2770.                     value    = PLUGIN_JSFX;

  2771.                     valueStr = text.toRawUTF8();

  2772.                 }

  2773.             }

  2774. 

  2775.             if (option == -1)

  2776.             {

  2777.                 // check old stuff, unhandled now

  2778.                 if (tag == "GIG_PATH")

  2779.                     continue;

  2780.                 // ignored tags

  2781.                 if (tag == "LADSPA_PATH" || tag == "DSSI_PATH" || tag == "LV2_PATH" || tag == "VST2_PATH")

  2782.                     continue;

  2783.                 if (tag == "VST3_PATH" || tag == "AU_PATH")

  2784.                     continue;

  2785.                 if (tag == "SF2_PATH" || tag == "SFZ_PATH" || tag == "JSFX_PATH")

  2786.                     continue;

  2787. 

  2788.                 // hmm something is wrong..

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

  2790.                 continue;

  2791.             }

  2792. 

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

  2794.         }

  2795. 

  2796.         if (pData->aboutToClose)

  2797.             return true;

  2798. 

  2799.         if (pData->actionCanceled)

  2800.         {

  2801.             setLastError("Project load canceled");

  2802.             return false;

  2803.         }

  2804.     }

  2805. 

  2806.     // now setup transport

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

  2808.     {

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

  2810.         {

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

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

  2813. 

  2814.             // some sane limits

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

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

  2817. 

  2818.             if (pData->aboutToClose)

  2819.                 return true;

  2820. 

  2821.             if (pData->actionCanceled)

  2822.             {

  2823.                 setLastError("Project load canceled");

  2824.                 return false;

  2825.             }

  2826.         }

  2827.     }

  2828. 

  2829.     // and we handle plugins

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

  2831.     {

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

  2833. 

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

  2835.         {

  2836.             CarlaStateSave stateSave;

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

  2838. 

  2839.             if (pData->aboutToClose)

  2840.                 return true;

  2841. 

  2842.             if (pData->actionCanceled)

  2843.             {

  2844.                 setLastError("Project load canceled");

  2845.                 return false;

  2846.             }

  2847. 

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

  2849. 

  2850. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2852.             // FIXME Remove on 2.1 release

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

  2854.             {

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

  2856.                 {

  2857.                     const uint pluginId = pData->curPluginCount;

  2858. 

  2859.                     if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  2860.                     {

  2861.                         if (pData->aboutToClose)

  2862.                             return true;

  2863. 

  2864.                         if (pData->actionCanceled)

  2865.                         {

  2866.                             setLastError("Project load canceled");

  2867.                             return false;

  2868.                         }

  2869. 

  2870.                         String lsState;

  2871.                         lsState << "0.35\n";

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

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

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

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

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

  2877. 

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

  2879.                         plugin->restoreLV2State(true);

  2880. 

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

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

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

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

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

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

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

  2888.                         plugin->setEnabled(true);

  2889. 

  2890.                         ++pData->curPluginCount;

  2891.                         callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, plugin->getType(),

  2892.                                  0, 0, 0.0f,

  2893.                                  plugin->getName());

  2894. 

  2895.                         if (isPatchbay)

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

  2897.                     }

  2898.                     else

  2899.                     {

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

  2901.                     }

  2902.                 }

  2903.                 else

  2904.                 {

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

  2906.                 }

  2907. 

  2908.                 callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  2909.                 continue;

  2910.             }

  2911. # ifdef SFZ_FILES_USING_SFIZZ

  2912.             if (std::strcmp(stateSave.type, "SFZ") == 0)

  2913.             {

  2914.                 if (addPlugin(PLUGIN_LV2, "", stateSave.name, "http://sfztools.github.io/sfizz", 0, nullptr))

  2915.                 {

  2916.                     const uint pluginId = pData->curPluginCount;

  2917. 

  2918.                     if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  2919.                     {

  2920.                         if (pData->aboutToClose)

  2921.                             return true;

  2922. 

  2923.                         if (pData->actionCanceled)

  2924.                         {

  2925.                             setLastError("Project load canceled");

  2926.                             return false;

  2927.                         }

  2928. 

  2929.                         plugin->setCustomData(LV2_ATOM__Path,

  2930.                                               "http://sfztools.github.io/sfizz:sfzfile",

  2931.                                               stateSave.binary,

  2932.                                               false);

  2933. 

  2934.                         plugin->restoreLV2State(true);

  2935. 

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

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

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

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

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

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

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

  2943.                         plugin->setEnabled(true);

  2944. 

  2945.                         ++pData->curPluginCount;

  2946.                         callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, plugin->getType(),

  2947.                                  0, 0, 0.0f,

  2948.                                  plugin->getName());

  2949. 

  2950.                         if (isPatchbay)

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

  2952.                     }

  2953.                     else

  2954.                     {

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

  2956.                     }

  2957.                 }

  2958.                 else

  2959.                 {

  2960.                     carla_stderr2("Failed to load a sfizz LV2 plugin, SFZ file won't be loaded");

  2961.                 }

  2962. 

  2963.                 callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  2964.                 continue;

  2965.             }

  2966. # endif

  2967. #endif

  2968. 

  2969.             const void* extraStuff    = nullptr;

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

  2971. 

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

  2973. 

  2974.             switch (ptype)

  2975.             {

  2976.             case PLUGIN_SF2:

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

  2978.                     extraStuff = kTrue;

  2979.                 // fall through

  2980.             case PLUGIN_LADSPA:

  2981.             case PLUGIN_DSSI:

  2982.             case PLUGIN_VST2:

  2983.             case PLUGIN_VST3:

  2984.             case PLUGIN_SFZ:

  2985.             case PLUGIN_JSFX:

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

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

  2988.                 {

  2989.                     const char* searchPath;

  2990. 

  2991.                     switch (ptype)

  2992.                     {

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

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

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

  2996.                     case PLUGIN_VST3:   searchPath = pData->options.pathVST3;   break;

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

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

  2999.                     case PLUGIN_JSFX:   searchPath = pData->options.pathJSFX;   break;

  3000.                     default:            searchPath = nullptr;                   break;

  3001.                     }

  3002. 

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

  3004.                     {

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

  3006.                                      stateSave.binary);

  3007. 

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

  3009. 

  3010.                         if (result.isEmpty())

  3011.                         {

  3012.                             switch (ptype)

  3013.                             {

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

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

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

  3017.                             case PLUGIN_VST3:   searchPath = std::getenv("VST3_PATH");   break;

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

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

  3020.                             case PLUGIN_JSFX:   searchPath = std::getenv("JSFX_PATH");   break;

  3021.                             default:            searchPath = nullptr;                    break;

  3022.                             }

  3023. 

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

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

  3026.                         }

  3027. 

  3028.                         if (result.isNotEmpty())

  3029.                         {

  3030.                             delete[] stateSave.binary;

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

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

  3033.                         }

  3034.                         else

  3035.                         {

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

  3037.                         }

  3038. 

  3039.                         callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  3040.                     }

  3041.                 }

  3042.                 break;

  3043.             default:

  3044.                 break;

  3045.             }

  3046. 

  3047.             BinaryType btype;

  3048. 

  3049.             switch (ptype)

  3050.             {

  3051.             case PLUGIN_LADSPA:

  3052.             case PLUGIN_DSSI:

  3053.             case PLUGIN_LV2:

  3054.             case PLUGIN_VST2:

  3055.             case PLUGIN_VST3:

  3056.                 btype = getBinaryTypeFromFile(stateSave.binary);

  3057.                 break;

  3058.             default:

  3059.                 btype = BINARY_NATIVE;

  3060.                 break;

  3061.             }

  3062. 

  3063.             if (addPlugin(btype, ptype, stateSave.binary,

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

  3065.             {

  3066. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3067.                 const uint pluginId = pData->curPluginCount;

  3068. #else

  3069.                 const uint pluginId = 0;

  3070. #endif

  3071. 

  3072.                 if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  3073.                 {

  3074.                     if (pData->aboutToClose)

  3075.                         return true;

  3076. 

  3077.                     if (pData->actionCanceled)

  3078.                     {

  3079.                         setLastError("Project load canceled");

  3080.                         return false;

  3081.                     }

  3082. 

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

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

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

  3086. 

  3087.                     plugin->loadStateSave(stateSave);

  3088. 

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

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

  3091.                      *        as we want to load state first.

  3092.                      */

  3093.                     plugin->setEnabled(true);

  3094. 

  3095.                     ++pData->curPluginCount;

  3096.                     callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, plugin->getType(),

  3097.                              0, 0, 0.0f,

  3098.                              plugin->getName());

  3099. 

  3100. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3101.                     if (isPatchbay)

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

  3103. #endif

  3104.                 }

  3105.                 else

  3106.                 {

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

  3108.                 }

  3109.             }

  3110.             else

  3111.             {

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

  3113.             }

  3114. 

  3115.             if (! isPreset)

  3116.                 callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  3117.         }

  3118. 

  3119.         if (isPreset)

  3120.         {

  3121.             callback(true, true, ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

  3122.             callback(true, true, ENGINE_CALLBACK_CANCELABLE_ACTION, 0, 0, 0, 0, 0.0f, "Loading project");

  3123.             return true;

  3124.         }

  3125.     }

  3126. 

  3127. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3128.     // tell bridges we're done loading

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

  3130.     {

  3131.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

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

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

  3134.     }

  3135. 

  3136.     if (pData->aboutToClose)

  3137.         return true;

  3138. 

  3139.     if (pData->actionCanceled)

  3140.     {

  3141.         setLastError("Project load canceled");

  3142.         return false;

  3143.     }

  3144. 

  3145.     // now we handle positions

  3146.     bool loadingAsExternal;

  3147.     std::map<water::String, water::String> mapGroupNamesInternal, mapGroupNamesExternal;

  3148. 

  3149.     bool hasInternalPositions = false;

  3150. 

  3151.     if (XmlElement* const elemPatchbay = xmlElement->getChildByName("Patchbay"))

  3152.     {

  3153.         hasInternalPositions = true;

  3154. 

  3155.         if (XmlElement* const elemPositions = elemPatchbay->getChildByName("Positions"))

  3156.         {

  3157.             String name;

  3158.             PatchbayPosition ppos = { nullptr, -1, 0, 0, 0, 0, false };

  3159. 

  3160.             for (XmlElement* patchElem = elemPositions->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3161.             {

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

  3163. 

  3164.                 if (patchTag != "Position")

  3165.                     continue;

  3166. 

  3167.                 XmlElement* const patchName = patchElem->getChildByName("Name");

  3168.                 CARLA_SAFE_ASSERT_CONTINUE(patchName != nullptr);

  3169. 

  3170.                 const String nameText(patchName->getAllSubText().trim());

  3171.                 name = xmlSafeString(nameText, false);

  3172. 

  3173.                 ppos.name = name.toRawUTF8();

  3174.                 ppos.x1 = patchElem->getIntAttribute("x1");

  3175.                 ppos.y1 = patchElem->getIntAttribute("y1");

  3176.                 ppos.x2 = patchElem->getIntAttribute("x2");

  3177.                 ppos.y2 = patchElem->getIntAttribute("y2");

  3178.                 ppos.pluginId = patchElem->getIntAttribute("pluginId", -1);

  3179.                 ppos.dealloc = false;

  3180. 

  3181.                 loadingAsExternal = ppos.pluginId >= 0 && isMultiClient;

  3182. 

  3183.                 if (name.isNotEmpty() && restorePatchbayGroupPosition(loadingAsExternal, ppos))

  3184.                 {

  3185.                     if (name != ppos.name)

  3186.                     {

  3187.                         carla_stdout("Converted client name '%s' to '%s' for this session",

  3188.                                      name.toRawUTF8(), ppos.name);

  3189.                         if (loadingAsExternal)

  3190.                             mapGroupNamesExternal[name] = ppos.name;

  3191.                         else

  3192.                             mapGroupNamesInternal[name] = ppos.name;

  3193.                     }

  3194. 

  3195.                     if (ppos.dealloc)

  3196.                         std::free(const_cast<char*>(ppos.name));

  3197.                 }

  3198.             }

  3199. 

  3200.             if (pData->aboutToClose)

  3201.                 return true;

  3202. 

  3203.             if (pData->actionCanceled)

  3204.             {

  3205.                 setLastError("Project load canceled");

  3206.                 return false;

  3207.             }

  3208.         }

  3209.     }

  3210. 

  3211.     if (XmlElement* const elemPatchbay = xmlElement->getChildByName("ExternalPatchbay"))

  3212.     {

  3213.         if (XmlElement* const elemPositions = elemPatchbay->getChildByName("Positions"))

  3214.         {

  3215.             String name;

  3216.             PatchbayPosition ppos = { nullptr, -1, 0, 0, 0, 0, false };

  3217. 

  3218.             for (XmlElement* patchElem = elemPositions->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3219.             {

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

  3221. 

  3222.                 if (patchTag != "Position")

  3223.                     continue;

  3224. 

  3225.                 XmlElement* const patchName = patchElem->getChildByName("Name");

  3226.                 CARLA_SAFE_ASSERT_CONTINUE(patchName != nullptr);

  3227. 

  3228.                 const String nameText(patchName->getAllSubText().trim());

  3229.                 name = xmlSafeString(nameText, false);

  3230. 

  3231.                 ppos.name = name.toRawUTF8();

  3232.                 ppos.x1 = patchElem->getIntAttribute("x1");

  3233.                 ppos.y1 = patchElem->getIntAttribute("y1");

  3234.                 ppos.x2 = patchElem->getIntAttribute("x2");

  3235.                 ppos.y2 = patchElem->getIntAttribute("y2");

  3236.                 ppos.pluginId = patchElem->getIntAttribute("pluginId", -1);

  3237.                 ppos.dealloc = false;

  3238. 

  3239.                 loadingAsExternal = ppos.pluginId < 0 || hasInternalPositions || !isPatchbay;

  3240. 

  3241.                 carla_debug("loadingAsExternal: %i because %i %i %i",

  3242.                             loadingAsExternal, ppos.pluginId < 0, hasInternalPositions, !isPatchbay);

  3243. 

  3244.                 if (name.isNotEmpty() && restorePatchbayGroupPosition(loadingAsExternal, ppos))

  3245.                 {

  3246.                     if (name != ppos.name)

  3247.                     {

  3248.                         carla_stdout("Converted client name '%s' to '%s' for this session",

  3249.                                      name.toRawUTF8(), ppos.name);

  3250. 

  3251.                         if (loadingAsExternal)

  3252.                             mapGroupNamesExternal[name] = ppos.name;

  3253.                         else

  3254.                             mapGroupNamesInternal[name] = ppos.name;

  3255.                     }

  3256. 

  3257.                     if (ppos.dealloc)

  3258.                         std::free(const_cast<char*>(ppos.name));

  3259.                 }

  3260.             }

  3261. 

  3262.             if (pData->aboutToClose)

  3263.                 return true;

  3264. 

  3265.             if (pData->actionCanceled)

  3266.             {

  3267.                 setLastError("Project load canceled");

  3268.                 return false;

  3269.             }

  3270.         }

  3271.     }

  3272. 

  3273.     bool hasInternalConnections = false;

  3274. 

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

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

  3277.     {

  3278.         hasInternalConnections = true;

  3279. 

  3280.         if (isPatchbay)

  3281.         {

  3282.             water::String sourcePort, targetPort;

  3283. 

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

  3285.             {

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

  3287. 

  3288.                 if (patchTag != "Connection")

  3289.                     continue;

  3290. 

  3291.                 sourcePort.clear();

  3292.                 targetPort.clear();

  3293. 

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

  3295.                 {

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

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

  3298. 

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

  3300.                         sourcePort = xmlSafeString(text, false);

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

  3302.                         targetPort = xmlSafeString(text, false);

  3303.                 }

  3304. 

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

  3306.                 {

  3307.                     std::map<water::String, water::String>& map(mapGroupNamesInternal);

  3308.                     std::map<water::String, water::String>::iterator it;

  3309. 

  3310.                     if ((it = map.find(sourcePort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3311.                         sourcePort = it->second + sourcePort.fromFirstOccurrenceOf(":", true, false);

  3312.                     if ((it = map.find(targetPort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3313.                         targetPort = it->second + targetPort.fromFirstOccurrenceOf(":", true, false);

  3314. 

  3315.                     restorePatchbayConnection(false, sourcePort.toRawUTF8(), targetPort.toRawUTF8());

  3316.                 }

  3317.             }

  3318. 

  3319.             if (pData->aboutToClose)

  3320.                 return true;

  3321. 

  3322.             if (pData->actionCanceled)

  3323.             {

  3324.                 setLastError("Project load canceled");

  3325.                 return false;

  3326.             }

  3327.         }

  3328.     }

  3329. 

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

  3331.     bool loadExternalConnections;

  3332. 

  3333.     if (alwaysLoadConnections)

  3334.     {

  3335.         loadExternalConnections = true;

  3336.     }

  3337.     else

  3338.     {

  3339.         /**/ if (std::strcmp(getCurrentDriverName(), "JACK") != 0)

  3340.             loadExternalConnections = true;

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

  3342.             loadExternalConnections = false;

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

  3344.             loadExternalConnections = false;

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

  3346.             loadExternalConnections = false;

  3347.         else

  3348.             loadExternalConnections = true;

  3349.     }

  3350. 

  3351.     // plus external connections too

  3352.     if (loadExternalConnections)

  3353.     {

  3354.         bool isExternal;

  3355.         loadingAsExternal = hasInternalConnections &&

  3356.             (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || isPatchbay);

  3357. 

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

  3359.         {

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

  3361. 

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

  3363.             if (tagName == "Patchbay")

  3364.             {

  3365.                 if (isPatchbay)

  3366.                     continue;

  3367.                 isExternal = false;

  3368.                 loadingAsExternal = true;

  3369.             }

  3370.             // or load external patchbay connections

  3371.             else if (tagName == "ExternalPatchbay")

  3372.             {

  3373.                 if (! isPatchbay)

  3374.                     loadingAsExternal = true;

  3375.                 isExternal = true;

  3376.             }

  3377.             else

  3378.             {

  3379.                 continue;

  3380.             }

  3381. 

  3382.             water::String sourcePort, targetPort;

  3383. 

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

  3385.             {

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

  3387. 

  3388.                 if (patchTag != "Connection")

  3389.                     continue;

  3390. 

  3391.                 sourcePort.clear();

  3392.                 targetPort.clear();

  3393. 

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

  3395.                 {

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

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

  3398. 

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

  3400.                         sourcePort = xmlSafeString(text, false);

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

  3402.                         targetPort = xmlSafeString(text, false);

  3403.                 }

  3404. 

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

  3406.                 {

  3407.                     std::map<water::String, water::String>& map(loadingAsExternal ? mapGroupNamesExternal

  3408.                                                                                   : mapGroupNamesInternal);

  3409.                     std::map<water::String, water::String>::iterator it;

  3410. 

  3411.                     if (isExternal && isPatchbay && !loadingAsExternal && sourcePort.startsWith("system:capture_"))

  3412.                     {

  3413.                         water::String internalPort = sourcePort.trimCharactersAtStart("system:capture_");

  3414. 

  3415.                         if (pData->graph.getNumAudioOuts() < 3)

  3416.                         {

  3417.                             /**/ if (internalPort == "1")

  3418.                                 internalPort = "Audio Input:Left";

  3419.                             else if (internalPort == "2")

  3420.                                 internalPort = "Audio Input:Right";

  3421.                             else if (internalPort == "3")

  3422.                                 internalPort = "Audio Input:Sidechain";

  3423.                             else

  3424.                                 continue;

  3425.                         }

  3426.                         else

  3427.                         {

  3428.                             internalPort = "Audio Input:Capture " + internalPort;

  3429.                         }

  3430. 

  3431.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3432.                                      sourcePort.toRawUTF8(), internalPort.toRawUTF8());

  3433.                         sourcePort = internalPort;

  3434.                     }

  3435.                     else if (!isExternal && isMultiClient && sourcePort.startsWith("Audio Input:"))

  3436.                     {

  3437.                         water::String externalPort = sourcePort.trimCharactersAtStart("Audio Input:");

  3438. 

  3439.                         /**/ if (externalPort == "Left")

  3440.                             externalPort = "system:capture_1";

  3441.                         else if (externalPort == "Right")

  3442.                             externalPort = "system:capture_2";

  3443.                         else if (externalPort == "Sidechain")

  3444.                             externalPort = "system:capture_3";

  3445.                         else

  3446.                             externalPort = "system:capture_ " + externalPort.trimCharactersAtStart("Capture ");

  3447. 

  3448.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3449.                                      sourcePort.toRawUTF8(), externalPort.toRawUTF8());

  3450.                         sourcePort = externalPort;

  3451.                     }

  3452.                     else if ((it = map.find(sourcePort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3453.                     {

  3454.                         sourcePort = it->second + sourcePort.fromFirstOccurrenceOf(":", true, false);

  3455.                     }

  3456. 

  3457.                     if (isExternal && isPatchbay && !loadingAsExternal && targetPort.startsWith("system:playback_"))

  3458.                     {

  3459.                         water::String internalPort = targetPort.trimCharactersAtStart("system:playback_");

  3460. 

  3461.                         if (pData->graph.getNumAudioOuts() < 3)

  3462.                         {

  3463.                             /**/ if (internalPort == "1")

  3464.                                 internalPort = "Audio Output:Left";

  3465.                             else if (internalPort == "2")

  3466.                                 internalPort = "Audio Output:Right";

  3467.                             else

  3468.                                 continue;

  3469.                         }

  3470.                         else

  3471.                         {

  3472.                             internalPort = "Audio Input:Playback " + internalPort;

  3473.                         }

  3474. 

  3475.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3476.                                      targetPort.toRawUTF8(), internalPort.toRawUTF8());

  3477.                         targetPort = internalPort;

  3478.                     }

  3479.                     else if (!isExternal && isMultiClient && targetPort.startsWith("Audio Output:"))

  3480.                     {

  3481.                         water::String externalPort = targetPort.trimCharactersAtStart("Audio Output:");

  3482. 

  3483.                         /**/ if (externalPort == "Left")

  3484.                             externalPort = "system:playback_1";

  3485.                         else if (externalPort == "Right")

  3486.                             externalPort = "system:playback_2";

  3487.                         else

  3488.                             externalPort = "system:playback_ " + externalPort.trimCharactersAtStart("Playback ");

  3489. 

  3490.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3491.                                      targetPort.toRawUTF8(), externalPort.toRawUTF8());

  3492.                         targetPort = externalPort;

  3493.                     }

  3494.                     else if ((it = map.find(targetPort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3495.                     {

  3496.                         targetPort = it->second + targetPort.fromFirstOccurrenceOf(":", true, false);

  3497.                     }

  3498. 

  3499.                     restorePatchbayConnection(loadingAsExternal, sourcePort.toRawUTF8(), targetPort.toRawUTF8());

  3500.                 }

  3501.             }

  3502.             break;

  3503.         }

  3504.     }

  3505. #endif

  3506. 

  3507.     if (pData->options.resetXruns)

  3508.         clearXruns();

  3509. 

  3510.     callback(true, true, ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

  3511.     callback(true, true, ENGINE_CALLBACK_CANCELABLE_ACTION, 0, 0, 0, 0, 0.0f, "Loading project");

  3512. 

  3513.     carla_debug("CarlaEngine::loadProjectInternal(%p, %s) - END", &xmlDoc, bool2str(alwaysLoadConnections));

  3514.     return true;

  3515. 

  3516. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3517.     // unused

  3518.     (void)alwaysLoadConnections;

  3519. #endif

  3520. }

  3521. 

  3522. // -----------------------------------------------------------------------

  3523. 

  3524. CARLA_BACKEND_END_NAMESPACE