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

2375 lines
82KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. /* TODO:

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

  20.  * - implement processPatchbay()

  21.  * - implement oscSend_control_switch_plugins()

  22.  * - something about the peaks?

  23.  */

  24. 

  25. #include "CarlaEngineInternal.hpp"

  26. #include "CarlaPlugin.hpp"

  27. 

  28. #include "CarlaBackendUtils.hpp"

  29. #include "CarlaBinaryUtils.hpp"

  30. #include "CarlaEngineUtils.hpp"

  31. #include "CarlaMathUtils.hpp"

  32. #include "CarlaPipeUtils.hpp"

  33. #include "CarlaStateUtils.hpp"

  34. #include "CarlaMIDI.h"

  35. 

  36. #include "jackbridge/JackBridge.hpp"

  37. 

  38. #include "AppConfig.h"

  39. #include "juce_core/juce_core.h"

  40. 

  41. using juce::Array;

  42. using juce::CharPointer_UTF8;

  43. using juce::File;

  44. using juce::MemoryOutputStream;

  45. using juce::ScopedPointer;

  46. using juce::String;

  47. using juce::StringArray;

  48. using juce::XmlDocument;

  49. using juce::XmlElement;

  50. 

  51. CARLA_BACKEND_START_NAMESPACE

  52. 

  53. // -----------------------------------------------------------------------

  54. // Carla Engine

  55. 

  56. CarlaEngine::CarlaEngine()

  57.     : pData(new ProtectedData(this))

  58. {

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

  60. }

  61. 

  62. CarlaEngine::~CarlaEngine()

  63. {

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

  65. 

  66.     delete pData;

  67. }

  68. 

  69. // -----------------------------------------------------------------------

  70. // Static calls

  71. 

  72. uint CarlaEngine::getDriverCount()

  73. {

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

  75. 

  76.     uint count = 0;

  77. 

  78.     if (jackbridge_is_ok())

  79.         count += 1;

  80. 

  81. #ifndef BUILD_BRIDGE

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

  83.     count += getJuceApiCount();

  84. # else

  85.     count += getRtAudioApiCount();

  86. # endif

  87. #endif

  88. 

  89.     return count;

  90. }

  91. 

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

  93. {

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

  95. 

  96.     uint index(index2);

  97. 

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

  99.         return "JACK";

  100. 

  101. #ifndef BUILD_BRIDGE

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

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

  104.     {

  105.         if (index < count)

  106.             return getJuceApiName(index);

  107.         index -= count;

  108.     }

  109. # else

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

  111.     {

  112.         if (index < count)

  113.             return getRtAudioApiName(index);

  114.         index -= count;

  115.     }

  116. # endif

  117. #endif

  118. 

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

  120.     return nullptr;

  121. }

  122. 

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

  124. {

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

  126. 

  127.     uint index(index2);

  128. 

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

  130.     {

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

  132.         return ret;

  133.     }

  134. 

  135. #ifndef BUILD_BRIDGE

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

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

  138.     {

  139.         if (index < count)

  140.             return getJuceApiDeviceNames(index);

  141.         index -= count;

  142.     }

  143. # else

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

  145.     {

  146.         if (index < count)

  147.             return getRtAudioApiDeviceNames(index);

  148.         index -= count;

  149.     }

  150. # endif

  151. #endif

  152. 

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

  154.     return nullptr;

  155. }

  156. 

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

  158. {

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

  160. 

  161.     uint index(index2);

  162. 

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

  164.     {

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

  166.         static EngineDriverDeviceInfo devInfo;

  167.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  168.         devInfo.bufferSizes = bufSizes;

  169.         devInfo.sampleRates = nullptr;

  170.         return &devInfo;

  171.     }

  172. 

  173. #ifndef BUILD_BRIDGE

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

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

  176.     {

  177.         if (index < count)

  178.             return getJuceDeviceInfo(index, deviceName);

  179.         index -= count;

  180.     }

  181. # else

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

  183.     {

  184.         if (index < count)

  185.             return getRtAudioDeviceInfo(index, deviceName);

  186.         index -= count;

  187.     }

  188. # endif

  189. #endif

  190. 

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

  192.     return nullptr;

  193. }

  194. 

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

  196. {

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

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

  199. 

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

  201.         return newJack();

  202. 

  203. #ifndef BUILD_BRIDGE

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

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

  206.     // macos

  207. 

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

  209.         return newJuce(AUDIO_API_CORE);

  210. 

  211.     // -------------------------------------------------------------------

  212.     // windows

  213. 

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

  215.         return newJuce(AUDIO_API_ASIO);

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

  217.         return newJuce(AUDIO_API_DS);

  218. #else

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

  220.     // common

  221. 

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

  223.         return newRtAudio(AUDIO_API_JACK);

  224. 

  225.     // -------------------------------------------------------------------

  226.     // linux

  227. 

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

  229.         return newRtAudio(AUDIO_API_ALSA);

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

  231.         return newRtAudio(AUDIO_API_OSS);

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

  233.         return newRtAudio(AUDIO_API_PULSE);

  234. # endif

  235. #endif

  236. 

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

  238.     return nullptr;

  239. }

  240. 

  241. // -----------------------------------------------------------------------

  242. // Constant values

  243. 

  244. uint CarlaEngine::getMaxClientNameSize() const noexcept

  245. {

  246.     return STR_MAX/2;

  247. }

  248. 

  249. uint CarlaEngine::getMaxPortNameSize() const noexcept

  250. {

  251.     return STR_MAX;

  252. }

  253. 

  254. uint CarlaEngine::getCurrentPluginCount() const noexcept

  255. {

  256.     return pData->curPluginCount;

  257. }

  258. 

  259. uint CarlaEngine::getMaxPluginNumber() const noexcept

  260. {

  261.     return pData->maxPluginNumber;

  262. }

  263. 

  264. // -----------------------------------------------------------------------

  265. // Virtual, per-engine type calls

  266. 

  267. bool CarlaEngine::close()

  268. {

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

  270. 

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

  272.     {

  273.         pData->aboutToClose = true;

  274.         removeAllPlugins();

  275.     }

  276. 

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

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

  279.         oscSend_control_exit();

  280. #endif

  281. 

  282.     pData->close();

  283. 

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

  285.     return true;

  286. }

  287. 

  288. bool CarlaEngine::usesConstantBufferSize() const noexcept

  289. {

  290.     return true;

  291. }

  292. 

  293. void CarlaEngine::idle() noexcept

  294. {

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

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

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

  298. 

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

  300.     {

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

  302. 

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

  304.         {

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

  306. 

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

  308.             {

  309.                 try {

  310.                     plugin->uiIdle();

  311.                 } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  312.             }

  313.         }

  314.     }

  315. 

  316. #ifdef HAVE_LIBLO

  317.     pData->osc.idle();

  318. #endif

  319. }

  320. 

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

  322. {

  323.     return new CarlaEngineClient(*this);

  324. }

  325. 

  326. // -----------------------------------------------------------------------

  327. // Plugin management

  328. 

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

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

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

  332. {

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

  334. #ifndef BUILD_BRIDGE

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

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

  337. #endif

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

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

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

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

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

  343. 

  344.     uint id;

  345. 

  346. #ifndef BUILD_BRIDGE

  347.     CarlaPlugin* oldPlugin = nullptr;

  348. 

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

  350.     {

  351.         id = pData->nextPluginId;

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

  353. 

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

  355. 

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

  357.     }

  358.     else

  359. #endif

  360.     {

  361.         id = pData->curPluginCount;

  362. 

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

  364.         {

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

  366.             return false;

  367.         }

  368. 

  369. #ifndef BUILD_BRIDGE

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

  371. #endif

  372.     }

  373. 

  374.     CarlaPlugin::Initializer initializer = {

  375.         this,

  376.         id,

  377.         filename,

  378.         name,

  379.         label,

  380.         uniqueId,

  381.         options

  382.     };

  383. 

  384.     CarlaPlugin* plugin = nullptr;

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

  386. 

  387.     if (bridgeBinary.isNotEmpty())

  388.     {

  389.         if (btype == BINARY_NATIVE)

  390.         {

  391. #ifdef CARLA_OS_WIN

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

  393. #else

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

  395. #endif

  396.         }

  397.         else

  398.         {

  399.             switch (btype)

  400.             {

  401.             case BINARY_POSIX32:

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

  403.                 break;

  404.             case BINARY_POSIX64:

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

  406.                 break;

  407.             case BINARY_WIN32:

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

  409.                 break;

  410.             case BINARY_WIN64:

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

  412.                 break;

  413.             default:

  414.                 bridgeBinary.clear();

  415.                 break;

  416.             }

  417.         }

  418. 

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

  420.             bridgeBinary.clear();

  421.     }

  422. 

  423.     // Prefer bridges for some specific plugins

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

  425. 

  426. #ifndef BUILD_BRIDGE

  427.     if (! preferBridges)

  428.     {

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

  430.         {

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

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

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

  434.             {

  435.                 preferBridges = true;

  436.             }

  437.         }

  438. # if 0

  439.         else if (ptype == PLUGIN_VST2)

  440.         {

  441.             /*

  442.             char uniqueIdChars[5] = {

  443.                 static_cast<char>((uniqueId & 0xFF000000) >> 24),

  444.                 static_cast<char>((uniqueId & 0x00FF0000) >> 16),

  445.                 static_cast<char>((uniqueId & 0x0000FF00) >>  8),

  446.                 static_cast<char>((uniqueId & 0x000000FF) >>  1),

  447.                 0

  448.             };

  449.             */

  450. 

  451.             /**/ if (uniqueId == 1633895765 && std::strstr(filename, "/ACE.") != nullptr)

  452.                 preferBridges = true;

  453.             else if (uniqueId == 1433421876 && std::strstr(filename, "/Bazille.") != nullptr)

  454.                 preferBridges = true;

  455.             else if (uniqueId == 1147754081 && std::strstr(filename, "/Diva.") != nullptr)

  456.                 preferBridges = true;

  457.             else if (uniqueId == 1095583057 && std::strstr(filename, "/Filterscape.") != nullptr)

  458.                 preferBridges = true;

  459.             else if (uniqueId == 1179866689 && std::strstr(filename, "/Filterscape.") != nullptr)

  460.                 preferBridges = true;

  461.             else if (uniqueId == 1179865398 && std::strstr(filename, "/Filterscape.") != nullptr)

  462.                 preferBridges = true;

  463.             else if (uniqueId == 1749636677 && std::strstr(filename, "/Hive.") != nullptr)

  464.                 preferBridges = true;

  465.             else if (uniqueId == 1296452914 && std::strstr(filename, "/MFM2.") != nullptr)

  466.                 preferBridges = true;

  467.             else if (uniqueId == 1349477487 && std::strstr(filename, "/Podolski.") != nullptr)

  468.                 preferBridges = true;

  469.             else if (uniqueId == 1886548821 && std::strstr(filename, "/Presswerk.") != nullptr)

  470.                 preferBridges = true;

  471.             else if (uniqueId == 1969770582 && std::strstr(filename, "/Protoverb.") != nullptr)

  472.                 preferBridges = true;

  473.             else if (uniqueId == 1969771348 && std::strstr(filename, "/Satin.") != nullptr)

  474.                 preferBridges = true;

  475.             else if (uniqueId == 1667388281 && std::strstr(filename, "/TripleCheese.") != nullptr)

  476.                 preferBridges = true;

  477.             else if (uniqueId == 1952017974 && std::strstr(filename, "/TyrellN6.") != nullptr)

  478.                 preferBridges = true;

  479.             else if (uniqueId == 1432568113 && std::strstr(filename, "/Uhbik.") != nullptr)

  480.                 preferBridges = true;

  481.             else if (uniqueId == 1432568881 && std::strstr(filename, "/Uhbik.") != nullptr)

  482.                 preferBridges = true;

  483.             else if (uniqueId == 1432572209 && std::strstr(filename, "/Uhbik.") != nullptr)

  484.                 preferBridges = true;

  485.             else if (uniqueId == 1432569393 && std::strstr(filename, "/Uhbik.") != nullptr)

  486.                 preferBridges = true;

  487.             else if (uniqueId == 1432569649 && std::strstr(filename, "/Uhbik.") != nullptr)

  488.                 preferBridges = true;

  489.             else if (uniqueId == 1432571953 && std::strstr(filename, "/Uhbik.") != nullptr)

  490.                 preferBridges = true;

  491.             else if (uniqueId == 1382232375 && std::strstr(filename, "/Uhbik.") != nullptr)

  492.                 preferBridges = true;

  493.             else if (uniqueId == 1432572721 && std::strstr(filename, "/Uhbik.") != nullptr)

  494.                 preferBridges = true;

  495.             else if (uniqueId == 1432572977 && std::strstr(filename, "/Uhbik.") != nullptr)

  496.                 preferBridges = true;

  497.             else if (uniqueId == 1397572658 && std::strstr(filename, "/Zebra2.") != nullptr)

  498.                 preferBridges = true;

  499.             else if (uniqueId == 1397572659 && std::strstr(filename, "/Zebra2.") != nullptr)

  500.                 preferBridges = true;

  501.             else if (uniqueId == 1919243824 && std::strstr(filename, "/Zebra2.") != nullptr)

  502.                 preferBridges = true;

  503.             else if (uniqueId == 1397578034 && std::strstr(filename, "/Zebra2.") != nullptr)

  504.                 preferBridges = true;

  505.             else if (uniqueId == 1397573722 && std::strstr(filename, "/ZebraHZ.") != nullptr)

  506.                 preferBridges = true;

  507.         }

  508. # endif

  509.         // FIXME: linuxsampler inside carla-rack/patchbay plugin has some issues (only last kit makes noise)

  510.         else if (getType() == kEngineTypePlugin && (ptype == PLUGIN_GIG || ptype == PLUGIN_SFZ))

  511.         {

  512.             // if we're not loading a project consider all is ok

  513.             if (! pData->loadingProject)

  514.                 pData->firstLinuxSamplerInstance = true;

  515. 

  516.             // loading a project, revert first status if set

  517.             else if (pData->firstLinuxSamplerInstance)

  518.                 pData->firstLinuxSamplerInstance = false;

  519. 

  520.             // now check if bridge is needed

  521.             if (! pData->firstLinuxSamplerInstance)

  522.                 preferBridges = true;

  523.         }

  524.     }

  525. #endif // ! BUILD_BRIDGE

  526. 

  527.     if (ptype != PLUGIN_INTERNAL && (btype != BINARY_NATIVE || (preferBridges && bridgeBinary.isNotEmpty())))

  528.     {

  529.         if (bridgeBinary.isNotEmpty())

  530.         {

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

  532.         }

  533.         else

  534.         {

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

  536.             return false;

  537.         }

  538.     }

  539.     else

  540.     {

  541.         bool use16Outs;

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

  543. 

  544.         switch (ptype)

  545.         {

  546.         case PLUGIN_NONE:

  547.             break;

  548. 

  549.         case PLUGIN_INTERNAL:

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

  551.             {

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

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

  554.             }

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

  556.             {

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

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

  559.             }

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

  561.             {

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

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

  564.             }

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

  566.             {

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

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

  569.             }*/

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

  571.             break;

  572. 

  573.         case PLUGIN_LADSPA:

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

  575.             break;

  576. 

  577.         case PLUGIN_DSSI:

  578.             if (CarlaString(filename).contains("dssi-vst", true))

  579.             {

  580.                 const ScopedEngineEnvironmentLocker _seel(this);

  581.                 const ScopedEnvVar _sev("VST_PATH", pData->options.pathVST2);

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

  583.             }

  584.             else

  585.             {

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

  587.             }

  588.             break;

  589. 

  590.         case PLUGIN_LV2:

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

  592.             break;

  593. 

  594.         case PLUGIN_VST2:

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

  596.             break;

  597. 

  598.         case PLUGIN_VST3:

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

  600.             break;

  601. 

  602.         case PLUGIN_AU:

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

  604.             break;

  605. 

  606.         case PLUGIN_GIG:

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

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

  609.             break;

  610. 

  611.         case PLUGIN_SF2:

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

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

  614.             break;

  615. 

  616.         case PLUGIN_SFZ:

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

  618.             break;

  619. 

  620.         case PLUGIN_JACK:

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

  622.             break;

  623.         }

  624.     }

  625. 

  626.     if (plugin == nullptr)

  627.         return false;

  628. 

  629.     plugin->reload();

  630. 

  631. #ifndef BUILD_BRIDGE

  632.     bool canRun = true;

  633. 

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

  635.     {

  636.         /**/ if (! plugin->canRunInRack())

  637.         {

  638.             setLastError("Carla's rack mode can only work with Mono or Stereo plugins, sorry!");

  639.             canRun = false;

  640.         }

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

  642.         {

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

  644.             canRun = false;

  645.         }

  646.     }

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

  648.     {

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

  650.         {

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

  652.             canRun = false;

  653.         }

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

  655.         {

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

  657.             canRun = false;

  658.         }

  659.     }

  660. 

  661.     if (! canRun)

  662.     {

  663.         delete plugin;

  664.         return false;

  665.     }

  666. 

  667. # ifdef HAVE_LIBLO

  668.     plugin->registerToOscClient();

  669. # endif

  670. #endif

  671. 

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

  673.     pluginData.plugin      = plugin;

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

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

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

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

  678. 

  679. #ifndef BUILD_BRIDGE

  680.     if (oldPlugin != nullptr)

  681.     {

  682.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  683. 

  684.         const ScopedThreadStopper sts(this);

  685. 

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

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

  688. 

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

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

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

  692. 

  693.         delete oldPlugin;

  694. 

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

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

  697. 

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

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

  700. 

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

  702.         plugin->setEnabled(true);

  703. 

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

  705.     }

  706.     else if (! pData->loadingProject)

  707. #endif

  708.     {

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

  710.         plugin->setEnabled(true);

  711. 

  712.         ++pData->curPluginCount;

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

  714. 

  715. #ifndef BUILD_BRIDGE

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

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

  718. #endif

  719.     }

  720. 

  721.     return true;

  722. }

  723. 

  724. bool CarlaEngine::addPlugin(const PluginType ptype, const char* const filename, const char* const name, const char* const label, const int64_t uniqueId, const void* const extra)

  725. {

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

  727. }

  728. 

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

  730. {

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

  732. #ifndef BUILD_BRIDGE

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

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

  735. #endif

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

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

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

  739. 

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

  741. 

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

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

  744. 

  745.     const ScopedThreadStopper sts(this);

  746. 

  747. #ifndef BUILD_BRIDGE

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

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

  750. 

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

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

  753. 

  754.     /*

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

  756.     {

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

  758.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  759.         plugin2->updateOscURL();

  760.     }

  761.     */

  762. 

  763. # ifdef HAVE_LIBLO

  764.     if (isOscControlRegistered())

  765.         oscSend_control_remove_plugin(id);

  766. # endif

  767. #else

  768.     pData->curPluginCount = 0;

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

  770. #endif

  771. 

  772.     delete plugin;

  773. 

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

  775.     return true;

  776. }

  777. 

  778. bool CarlaEngine::removeAllPlugins()

  779. {

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

  781. #ifndef BUILD_BRIDGE

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

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

  784. #endif

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

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

  787. 

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

  789.         return true;

  790. 

  791.     const ScopedThreadStopper sts(this);

  792. 

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

  794. 

  795. #ifndef BUILD_BRIDGE

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

  797.         pData->graph.removeAllPlugins();

  798. 

  799. # ifdef HAVE_LIBLO

  800.     if (isOscControlRegistered())

  801.     {

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

  803.             oscSend_control_remove_plugin(curPluginCount-i-1);

  804.     }

  805. # endif

  806. #endif

  807. 

  808.     const bool lockWait(isRunning());

  809.     const ScopedActionLock sal(this, kEnginePostActionZeroCount, 0, 0, lockWait);

  810. 

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

  812. 

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

  814.     {

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

  816. 

  817.         if (pluginData.plugin != nullptr)

  818.         {

  819.             delete pluginData.plugin;

  820.             pluginData.plugin = nullptr;

  821.         }

  822. 

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

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

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

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

  827. 

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

  829.     }

  830. 

  831.     return true;

  832. }

  833. 

  834. #ifndef BUILD_BRIDGE

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

  836. {

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

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

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

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

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

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

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

  844. 

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

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

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

  848. 

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

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

  851. 

  852.     plugin->setName(uniqueName);

  853. 

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

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

  856. 

  857.     delete[] uniqueName;

  858.     return plugin->getName();

  859. }

  860. 

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

  862. {

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

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

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

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

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

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

  869. 

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

  871. 

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

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

  874. 

  875.     char label[STR_MAX+1];

  876.     carla_zeroChars(label, STR_MAX+1);

  877.     plugin->getLabel(label);

  878. 

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

  880. 

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

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

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

  884.         return false;

  885. 

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

  887. 

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

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

  890. 

  891.     return true;

  892. }

  893. 

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

  895. {

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

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

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

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

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

  901. 

  902.     // might use this to reset

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

  904.     {

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

  906.         return true;

  907.     }

  908. 

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

  910. 

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

  912. 

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

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

  915. 

  916.     pData->nextPluginId = id;

  917. 

  918.     return true;

  919. }

  920. 

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

  922. {

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

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

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

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

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

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

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

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

  931. 

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

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

  934. 

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

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

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

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

  939. 

  940.     const ScopedThreadStopper sts(this);

  941. 

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

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

  944. 

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

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

  947. 

  948.     // TODO

  949.     /*

  950.     pluginA->updateOscURL();

  951.     pluginB->updateOscURL();

  952. 

  953.     if (isOscControlRegistered())

  954.         oscSend_control_switch_plugins(idA, idB);

  955.     */

  956. 

  957.     return true;

  958. }

  959. #endif

  960. 

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

  962. {

  963. #ifndef BUILD_BRIDGE

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

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

  966. #endif

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

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

  969. 

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

  971. }

  972. 

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

  974. {

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

  976. }

  977. 

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

  979. {

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

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

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

  983. 

  984.     CarlaString sname;

  985.     sname = name;

  986. 

  987.     if (sname.isEmpty())

  988.     {

  989.         sname = "(No name)";

  990.         return sname.dup();

  991.     }

  992. 

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

  994. 

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

  996.         return sname.dup();

  997. 

  998.     sname.truncate(maxNameSize);

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

  1000. 

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

  1002.     {

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

  1004. 

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

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

  1007.         {

  1008.             if (sname != pluginName)

  1009.                 continue;

  1010.         }

  1011. 

  1012.         // Check if string has already been modified

  1013.         {

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

  1015. 

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

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

  1018.             {

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

  1020. 

  1021.                 if (number == 9)

  1022.                 {

  1023.                     // next number is 10, 2 digits

  1024.                     sname.truncate(len-4);

  1025.                     sname += " (10)";

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

  1027.                 }

  1028.                 else

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

  1030. 

  1031.                 continue;

  1032.             }

  1033. 

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

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

  1036.             {

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

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

  1039. 

  1040.                 if (n2 == '9')

  1041.                 {

  1042.                     n2 = '0';

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

  1044.                 }

  1045.                 else

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

  1047. 

  1048.                 sname[len-2] = n2;

  1049.                 sname[len-3] = n3;

  1050. 

  1051.                 continue;

  1052.             }

  1053.         }

  1054. 

  1055.         // Modify string if not

  1056.         sname += " (2)";

  1057.     }

  1058. 

  1059.     return sname.dup();

  1060. }

  1061. 

  1062. // -----------------------------------------------------------------------

  1063. // Project management

  1064. 

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

  1066. {

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

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

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

  1070. 

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

  1072.     File file(jfilename);

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

  1074. 

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

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

  1077. 

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

  1079. 

  1080.     // -------------------------------------------------------------------

  1081. 

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

  1083.         return loadProject(filename);

  1084. 

  1085.     // -------------------------------------------------------------------

  1086. 

  1087.     if (extension == "gig")

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

  1089. 

  1090.     if (extension == "sf2")

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

  1092. 

  1093.     if (extension == "sfz")

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

  1095. 

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

  1097. 

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

  1099.     {

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

  1101.         {

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

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

  1104.             return true;

  1105.         }

  1106.         return false;

  1107.     }

  1108. 

  1109.     // -------------------------------------------------------------------

  1110. 

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

  1112.     {

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

  1114.         {

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

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

  1117.             return true;

  1118.         }

  1119.         return false;

  1120.     }

  1121. 

  1122.     // -------------------------------------------------------------------

  1123.     // ZynAddSubFX

  1124. 

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

  1126.     {

  1127. #ifdef HAVE_ZYN_DEPS

  1128.         CarlaString nicerName("Zyn - ");

  1129. 

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

  1131. 

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

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

  1134.         else

  1135.             nicerName += baseName;

  1136. 

  1137.         //nicerName

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

  1139.         {

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

  1141. 

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

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

  1144.             return true;

  1145.         }

  1146.         return false;

  1147. #else

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

  1149.         return false;

  1150. #endif

  1151.     }

  1152. 

  1153.     // -------------------------------------------------------------------

  1154.     // Direct plugin binaries

  1155. 

  1156. #ifdef CARLA_OS_MAC

  1157.     if (extension == "vst")

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

  1159. #else

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

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

  1162. #endif

  1163. 

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

  1165.     if (extension == "vst3")

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

  1167. #endif

  1168. 

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

  1170. 

  1171.     setLastError("Unknown file extension");

  1172.     return false;

  1173. }

  1174. 

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

  1176. {

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

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

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

  1180. 

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

  1182.     File file(jfilename);

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

  1184. 

  1185.     XmlDocument xml(file);

  1186.     return loadProjectInternal(xml);

  1187. }

  1188. 

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

  1190. {

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

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

  1193. 

  1194.     MemoryOutputStream out;

  1195.     saveProjectInternal(out);

  1196. 

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

  1198.     File file(jfilename);

  1199. 

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

  1201.         return true;

  1202. 

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

  1204.     return false;

  1205. }

  1206. 

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

  1208. // Information (base)

  1209. 

  1210. uint CarlaEngine::getHints() const noexcept

  1211. {

  1212.     return pData->hints;

  1213. }

  1214. 

  1215. uint32_t CarlaEngine::getBufferSize() const noexcept

  1216. {

  1217.     return pData->bufferSize;

  1218. }

  1219. 

  1220. double CarlaEngine::getSampleRate() const noexcept

  1221. {

  1222.     return pData->sampleRate;

  1223. }

  1224. 

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

  1226. {

  1227.     return pData->name;

  1228. }

  1229. 

  1230. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1231. {

  1232.     return pData->options.processMode;

  1233. }

  1234. 

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

  1236. {

  1237.     return pData->options;

  1238. }

  1239. 

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

  1241. {

  1242.     return pData->timeInfo;

  1243. }

  1244. 

  1245. // -----------------------------------------------------------------------

  1246. // Information (peaks)

  1247. 

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

  1249. {

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

  1251. 

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

  1253. }

  1254. 

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

  1256. {

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

  1258. 

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

  1260. }

  1261. 

  1262. // -----------------------------------------------------------------------

  1263. // Callback

  1264. 

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

  1266. {

  1267. #ifdef DEBUG

  1268.     if (action != ENGINE_CALLBACK_IDLE)

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

  1270. #endif

  1271. 

  1272. #ifdef BUILD_BRIDGE

  1273.     if (pData->isIdling)

  1274. #else

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

  1276. #endif

  1277.     {

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

  1279.     }

  1280. 

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

  1282.     {

  1283.         if (action == ENGINE_CALLBACK_IDLE)

  1284.             ++pData->isIdling;

  1285. 

  1286.         try {

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

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

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

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

  1291.             throw;

  1292. #endif

  1293.         } catch (...) {

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

  1295.         }

  1296. 

  1297.         if (action == ENGINE_CALLBACK_IDLE)

  1298.             --pData->isIdling;

  1299.     }

  1300. }

  1301. 

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

  1303. {

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

  1305. 

  1306.     pData->callback    = func;

  1307.     pData->callbackPtr = ptr;

  1308. }

  1309. 

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

  1311. // File Callback

  1312. 

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

  1314. {

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

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

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

  1318. 

  1319.     const char* ret = nullptr;

  1320. 

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

  1322.     {

  1323.         try {

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

  1325.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1326.     }

  1327. 

  1328.     return ret;

  1329. }

  1330. 

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

  1332. {

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

  1334. 

  1335.     pData->fileCallback    = func;

  1336.     pData->fileCallbackPtr = ptr;

  1337. }

  1338. 

  1339. // -----------------------------------------------------------------------

  1340. // Transport

  1341. 

  1342. void CarlaEngine::transportPlay() noexcept

  1343. {

  1344.     pData->timeInfo.playing = true;

  1345.     pData->time.setNeedsReset();

  1346. }

  1347. 

  1348. void CarlaEngine::transportPause() noexcept

  1349. {

  1350.     pData->timeInfo.playing = false;

  1351.     pData->time.setNeedsReset();

  1352. }

  1353. 

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

  1355. {

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

  1357. }

  1358. 

  1359. // -----------------------------------------------------------------------

  1360. // Error handling

  1361. 

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

  1363. {

  1364.     return pData->lastError;

  1365. }

  1366. 

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

  1368. {

  1369.     pData->lastError = error;

  1370. }

  1371. 

  1372. // -----------------------------------------------------------------------

  1373. // Misc

  1374. 

  1375. bool CarlaEngine::isAboutToClose() const noexcept

  1376. {

  1377.     return pData->aboutToClose;

  1378. }

  1379. 

  1380. bool CarlaEngine::setAboutToClose() noexcept

  1381. {

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

  1383. 

  1384.     pData->aboutToClose = true;

  1385. 

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

  1387. }

  1388. 

  1389. // -----------------------------------------------------------------------

  1390. // Global options

  1391. 

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

  1393. {

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

  1395. 

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

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

  1398. 

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

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

  1401.         return;

  1402. 

  1403.     switch (option)

  1404.     {

  1405.     case ENGINE_OPTION_DEBUG:

  1406.         break;

  1407. 

  1408.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1411.         break;

  1412. 

  1413.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

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

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

  1418.         pData->options.transportExtra = (valueStr != nullptr) ? carla_strdup_safe(valueStr) : nullptr;

  1419. 

  1420.         pData->time.setNeedsReset();

  1421. 

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

  1423.         // enable link now if needed

  1424.         {

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

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

  1427.         }

  1428. #endif

  1429.         break;

  1430. 

  1431.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1434.         break;

  1435. 

  1436.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1437. #ifdef BUILD_BRIDGE

  1438.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1439. #else

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

  1441. #endif

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

  1443.         break;

  1444. 

  1445.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1448.         break;

  1449. 

  1450.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1453.         break;

  1454. 

  1455.     case ENGINE_OPTION_MAX_PARAMETERS:

  1456.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1458.         break;

  1459. 

  1460.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1461.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1463.         break;

  1464. 

  1465.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1468.         break;

  1469. 

  1470.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1471.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1473.         break;

  1474. 

  1475.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1476.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1478.         break;

  1479. 

  1480.     case ENGINE_OPTION_AUDIO_DEVICE:

  1481.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1482. 

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

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

  1485. 

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

  1487.         break;

  1488. 

  1489.     case ENGINE_OPTION_PLUGIN_PATH:

  1490.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1491.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1492. 

  1493.         switch (value)

  1494.         {

  1495.         case PLUGIN_LADSPA:

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

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

  1498.             if (valueStr != nullptr)

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

  1500.             else

  1501.                 pData->options.pathLADSPA = nullptr;

  1502.             break;

  1503.         case PLUGIN_DSSI:

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

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

  1506.             if (valueStr != nullptr)

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

  1508.             else

  1509.                 pData->options.pathDSSI = nullptr;

  1510.             break;

  1511.         case PLUGIN_LV2:

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

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

  1514.             if (valueStr != nullptr)

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

  1516.             else

  1517.                 pData->options.pathLV2 = nullptr;

  1518.             break;

  1519.         case PLUGIN_VST2:

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

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

  1522.             if (valueStr != nullptr)

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

  1524.             else

  1525.                 pData->options.pathVST2 = nullptr;

  1526.             break;

  1527.         case PLUGIN_VST3:

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

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

  1530.             if (valueStr != nullptr)

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

  1532.             else

  1533.                 pData->options.pathVST3 = nullptr;

  1534.             break;

  1535.         case PLUGIN_GIG:

  1536.             if (pData->options.pathGIG != nullptr)

  1537.                 delete[] pData->options.pathGIG;

  1538.             if (valueStr != nullptr)

  1539.                 pData->options.pathGIG = carla_strdup_safe(valueStr);

  1540.             else

  1541.                 pData->options.pathGIG = nullptr;

  1542.             break;

  1543.         case PLUGIN_SF2:

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

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

  1546.             if (valueStr != nullptr)

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

  1548.             else

  1549.                 pData->options.pathSF2 = nullptr;

  1550.             break;

  1551.         case PLUGIN_SFZ:

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

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

  1554.             if (valueStr != nullptr)

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

  1556.             else

  1557.                 pData->options.pathSFZ = nullptr;

  1558.             break;

  1559.         default:

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

  1561.             break;

  1562.         }

  1563.         break;

  1564. 

  1565.     case ENGINE_OPTION_PATH_BINARIES:

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

  1567. 

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

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

  1570. 

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

  1572.         break;

  1573. 

  1574.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1576. 

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

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

  1579. 

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

  1581.         break;

  1582. 

  1583.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

  1585. #ifdef CARLA_OS_LINUX

  1586.         if (value != 0)

  1587.         {

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

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

  1590.         }

  1591.         else

  1592.         {

  1593.             ::unsetenv("LD_PRELOAD");

  1594.         }

  1595. #endif

  1596.         break;

  1597. 

  1598.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  1601.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1603.     }   break;

  1604. 

  1605.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  1606.         break;

  1607.     }

  1608. }

  1609. 

  1610. #ifdef HAVE_LIBLO

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

  1612. // OSC Stuff

  1613. 

  1614. # ifndef BUILD_BRIDGE

  1615. bool CarlaEngine::isOscControlRegistered() const noexcept

  1616. {

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

  1618. }

  1619. # endif

  1620. 

  1621. void CarlaEngine::idleOsc() const noexcept

  1622. {

  1623.     pData->osc.idle();

  1624. }

  1625. 

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

  1627. {

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

  1629. }

  1630. 

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

  1632. {

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

  1634. }

  1635. #endif

  1636. 

  1637. // -----------------------------------------------------------------------

  1638. // Helper functions

  1639. 

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

  1641. {

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

  1643. }

  1644. 

  1645. // -----------------------------------------------------------------------

  1646. // Internal stuff

  1647. 

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

  1649. {

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

  1651. 

  1652. #ifndef BUILD_BRIDGE

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

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

  1655.     {

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

  1657.     }

  1658. #endif

  1659. 

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

  1661. 

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

  1663.     {

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

  1665. 

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

  1667.             plugin->bufferSizeChanged(newBufferSize);

  1668.     }

  1669. 

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

  1671. }

  1672. 

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

  1674. {

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

  1676. 

  1677. #ifndef BUILD_BRIDGE

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

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

  1680.     {

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

  1682.     }

  1683. #endif

  1684. 

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

  1686. 

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

  1688.     {

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

  1690. 

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

  1692.             plugin->sampleRateChanged(newSampleRate);

  1693.     }

  1694. 

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

  1696. }

  1697. 

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

  1699. {

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

  1701. 

  1702. #ifndef BUILD_BRIDGE

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

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

  1705.     {

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

  1707.     }

  1708. #endif

  1709. 

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

  1711.     {

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

  1713. 

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

  1715.             plugin->offlineModeChanged(isOfflineNow);

  1716.     }

  1717. }

  1718. 

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

  1720. {

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

  1722. 

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

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

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

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

  1727. }

  1728. 

  1729. void CarlaEngine::saveProjectInternal(juce::MemoryOutputStream& outStream) const

  1730. {

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

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

  1733.     {

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

  1735. 

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

  1737.         {

  1738. #ifndef BUILD_BRIDGE

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

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

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

  1742. #endif

  1743.             plugin->prepareForSave();

  1744.         }

  1745.     }

  1746. 

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

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

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

  1750. 

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

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

  1753. 

  1754.     MemoryOutputStream outSettings(1024);

  1755. 

  1756.     // save appropriate engine settings

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

  1758. 

  1759.     //processMode

  1760.     //transportMode

  1761. 

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

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

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

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

  1766. 

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

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

  1769. 

  1770.     if (isPlugin)

  1771.     {

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

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

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

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

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

  1777.         outSettings << "  <GIG_PATH>"    << xmlSafeString(options.pathGIG,    true) << "</GIG_PATH>\n";

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

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

  1780.     }

  1781. 

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

  1783.     outStream << outSettings;

  1784. 

  1785.     char strBuf[STR_MAX+1];

  1786. 

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

  1788.     {

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

  1790. 

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

  1792.         {

  1793.             MemoryOutputStream outPlugin(4096), streamPlugin;

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

  1795. 

  1796.             outPlugin << "\n";

  1797. 

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

  1799.             plugin->getRealName(strBuf);

  1800. 

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

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

  1803. 

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

  1805.             outPlugin << streamPlugin;

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

  1807.             outStream << outPlugin;

  1808.         }

  1809.     }

  1810. 

  1811. #ifndef BUILD_BRIDGE

  1812.     // tell bridges we're done saving

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

  1814.     {

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

  1816. 

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

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

  1819.     }

  1820. 

  1821.     // save internal connections

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

  1823.     {

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

  1825.         {

  1826.             MemoryOutputStream outPatchbay(2048);

  1827. 

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

  1829. 

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

  1831.             {

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

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

  1834. 

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

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

  1837. 

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

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

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

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

  1842.             }

  1843. 

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

  1845.             outStream << outPatchbay;

  1846.         }

  1847.     }

  1848. 

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

  1850.     bool saveExternalConnections;

  1851. 

  1852.     /**/ if (isPlugin)

  1853.         saveExternalConnections = false;

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

  1855.         saveExternalConnections = true;

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

  1857.         saveExternalConnections = false;

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

  1859.         saveExternalConnections = false;

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

  1861.         saveExternalConnections = false;

  1862.     else

  1863.         saveExternalConnections = true;

  1864. 

  1865.     if (saveExternalConnections)

  1866.     {

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

  1868.         {

  1869.             MemoryOutputStream outPatchbay(2048);

  1870. 

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

  1872. 

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

  1874.             {

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

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

  1877. 

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

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

  1880. 

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

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

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

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

  1885.             }

  1886. 

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

  1888.             outStream << outPatchbay;

  1889.         }

  1890.     }

  1891. #endif

  1892. 

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

  1894. }

  1895. 

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

  1897. {

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

  1899. 

  1900.     // try direct filename first

  1901.     String jbinary(binary);

  1902. 

  1903.     // adjust for current platform

  1904. #ifdef CARLA_OS_WIN

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

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

  1907. #else

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

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

  1910. #endif

  1911. 

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

  1913. 

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

  1915. #ifdef CARLA_OS_MAC

  1916.     if (filename.endsWithIgnoreCase(".vst") || filename.endsWithIgnoreCase(".vst3"))

  1917.         searchFlags |= File::findDirectories;

  1918. #endif

  1919. 

  1920.     Array<File> results;

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

  1922.     {

  1923.         const File path(*it);

  1924. 

  1925.         results.clear();

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

  1927. 

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

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

  1930.     }

  1931. 

  1932.     // try changing extension

  1933. #if defined(CARLA_OS_MAC)

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

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

  1936. #elif defined(CARLA_OS_WIN)

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

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

  1939. #else

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

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

  1942. #endif

  1943.     else

  1944.         return String();

  1945. 

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

  1947.     {

  1948.         const File path(*it);

  1949. 

  1950.         results.clear();

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

  1952. 

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

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

  1955.     }

  1956. 

  1957.     return String();

  1958. }

  1959. 

  1960. bool CarlaEngine::loadProjectInternal(juce::XmlDocument& xmlDoc)

  1961. {

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

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

  1964. 

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

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

  1967. 

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

  1969.     {

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

  1971.         return false;

  1972.     }

  1973. 

  1974. #ifndef BUILD_BRIDGE

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

  1976. #endif

  1977. 

  1978.     // completely load file

  1979.     xmlElement = xmlDoc.getDocumentElement(false);

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

  1981. 

  1982.     if (pData->aboutToClose)

  1983.         return true;

  1984. 

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

  1986. 

  1987.     // engine settings

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

  1989.     {

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

  1991. 

  1992.         if (! tagName.equalsIgnoreCase("enginesettings"))

  1993.             continue;

  1994. 

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

  1996.         {

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

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

  1999. 

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

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

  2002. 

  2003.            int option = -1;

  2004.            int value  = 0;

  2005.            const char* valueStr = nullptr;

  2006. 

  2007.             /**/ if (tag.equalsIgnoreCase("forcestereo"))

  2008.             {

  2009.                 option = ENGINE_OPTION_FORCE_STEREO;

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

  2011.             }

  2012.             else if (tag.equalsIgnoreCase("preferpluginbridges"))

  2013.             {

  2014.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

  2015.                 value  = text.equalsIgnoreCase("true") ? 1 : 0;

  2016.             }

  2017.             else if (tag.equalsIgnoreCase("preferuibridges"))

  2018.             {

  2019.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

  2020.                 value  = text.equalsIgnoreCase("true") ? 1 : 0;

  2021.             }

  2022.             else if (tag.equalsIgnoreCase("uisalwaysontop"))

  2023.             {

  2024.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

  2025.                 value  = text.equalsIgnoreCase("true") ? 1 : 0;

  2026.             }

  2027.             else if (tag.equalsIgnoreCase("maxparameters"))

  2028.             {

  2029.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2030.                 value  = text.getIntValue();

  2031.             }

  2032.             else if (tag.equalsIgnoreCase("uibridgestimeout"))

  2033.             {

  2034.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2035.                 value  = text.getIntValue();

  2036.             }

  2037.             else if (isPlugin)

  2038.             {

  2039.                 /**/ if (tag.equalsIgnoreCase("LADSPA_PATH"))

  2040.                 {

  2041.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2042.                     value    = PLUGIN_LADSPA;

  2043.                     valueStr = text.toRawUTF8();

  2044.                 }

  2045.                 else if (tag.equalsIgnoreCase("DSSI_PATH"))

  2046.                 {

  2047.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2048.                     value    = PLUGIN_DSSI;

  2049.                     valueStr = text.toRawUTF8();

  2050.                 }

  2051.                 else if (tag.equalsIgnoreCase("LV2_PATH"))

  2052.                 {

  2053.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2054.                     value    = PLUGIN_LV2;

  2055.                     valueStr = text.toRawUTF8();

  2056.                 }

  2057.                 else if (tag.equalsIgnoreCase("VST2_PATH"))

  2058.                 {

  2059.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2060.                     value    = PLUGIN_VST2;

  2061.                     valueStr = text.toRawUTF8();

  2062.                 }

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

  2064.                 {

  2065.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2066.                     value    = PLUGIN_VST3;

  2067.                     valueStr = text.toRawUTF8();

  2068.                 }

  2069.                 else if (tag.equalsIgnoreCase("GIG_PATH"))

  2070.                 {

  2071.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2072.                     value    = PLUGIN_GIG;

  2073.                     valueStr = text.toRawUTF8();

  2074.                 }

  2075.                 else if (tag.equalsIgnoreCase("SF2_PATH"))

  2076.                 {

  2077.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2078.                     value    = PLUGIN_SF2;

  2079.                     valueStr = text.toRawUTF8();

  2080.                 }

  2081.                 else if (tag.equalsIgnoreCase("SFZ_PATH"))

  2082.                 {

  2083.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2084.                     value    = PLUGIN_SFZ;

  2085.                     valueStr = text.toRawUTF8();

  2086.                 }

  2087.             }

  2088. 

  2089.             CARLA_SAFE_ASSERT_CONTINUE(option != -1);

  2090. 

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

  2092.         }

  2093. 

  2094.         break;

  2095.     }

  2096. 

  2097.     if (pData->aboutToClose)

  2098.         return true;

  2099. 

  2100.     // handle plugins first

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

  2102.     {

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

  2104. 

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

  2106.         {

  2107.             CarlaStateSave stateSave;

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

  2109. 

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

  2111. 

  2112.             if (pData->aboutToClose)

  2113.                 return true;

  2114. 

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

  2116. 

  2117.             const void* extraStuff    = nullptr;

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

  2119. 

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

  2121. 

  2122.             switch (ptype)

  2123.             {

  2124.             case PLUGIN_GIG:

  2125.             case PLUGIN_SF2:

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

  2127.                     extraStuff = kTrue;

  2128.                 // fall through

  2129.             case PLUGIN_LADSPA:

  2130.             case PLUGIN_DSSI:

  2131.             case PLUGIN_VST2:

  2132.             case PLUGIN_VST3:

  2133.             case PLUGIN_SFZ:

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

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

  2136.                 {

  2137.                     const char* searchPath;

  2138. 

  2139.                     switch (ptype)

  2140.                     {

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

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

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

  2144.                     case PLUGIN_VST3:   searchPath = pData->options.pathVST3;   break;

  2145.                     case PLUGIN_GIG:    searchPath = pData->options.pathGIG;    break;

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

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

  2148.                     default:            searchPath = nullptr;                   break;

  2149.                     }

  2150. 

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

  2152.                     {

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

  2154.                                      stateSave.binary);

  2155. 

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

  2157. 

  2158.                         if (result.isEmpty())

  2159.                         {

  2160.                             switch (ptype)

  2161.                             {

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

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

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

  2165.                             case PLUGIN_VST3:   searchPath = std::getenv("VST3_PATH");   break;

  2166.                             case PLUGIN_GIG:    searchPath = std::getenv("GIG_PATH");    break;

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

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

  2169.                             default:            searchPath = nullptr;                    break;

  2170.                             }

  2171. 

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

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

  2174.                         }

  2175. 

  2176.                         if (result.isNotEmpty())

  2177.                         {

  2178.                             delete[] stateSave.binary;

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

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

  2181.                         }

  2182.                         else

  2183.                         {

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

  2185.                         }

  2186.                     }

  2187.                 }

  2188.                 break;

  2189.             default:

  2190.                 break;

  2191.             }

  2192. 

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

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

  2195.             {

  2196. #ifndef BUILD_BRIDGE

  2197.                 const uint pluginId = pData->curPluginCount;

  2198. #else

  2199.                 const uint pluginId = 0;

  2200. #endif

  2201. 

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

  2203.                 {

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

  2205. 

  2206.                     if (pData->aboutToClose)

  2207.                         return true;

  2208. 

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

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

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

  2212. 

  2213.                     plugin->loadStateSave(stateSave);

  2214. 

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

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

  2217.                      *        as we want to load state first.

  2218.                      */

  2219. #ifdef BUILD_BRIDGE

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

  2221. #else

  2222.                     ++pData->curPluginCount;

  2223. #endif

  2224. 

  2225.                     plugin->setEnabled(true);

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

  2227. 

  2228. #ifndef BUILD_BRIDGE

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

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

  2231. #endif

  2232.                 }

  2233.                 else

  2234.                 {

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

  2236.                 }

  2237.             }

  2238.             else

  2239.             {

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

  2241.             }

  2242.         }

  2243. 

  2244.         if (isPreset)

  2245.             return true;

  2246.     }

  2247. 

  2248. #ifndef BUILD_BRIDGE

  2249.     // tell bridges we're done loading

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

  2251.     {

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

  2253. 

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

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

  2256.     }

  2257. 

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

  2259. 

  2260.     if (pData->aboutToClose)

  2261.         return true;

  2262. 

  2263.     // handle connections (internal)

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

  2265.     {

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

  2267. 

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

  2269.         {

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

  2271. 

  2272.             if (! tagName.equalsIgnoreCase("patchbay"))

  2273.                 continue;

  2274. 

  2275.             CarlaString sourcePort, targetPort;

  2276. 

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

  2278.             {

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

  2280. 

  2281.                 sourcePort.clear();

  2282.                 targetPort.clear();

  2283. 

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

  2285.                     continue;

  2286. 

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

  2288.                 {

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

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

  2291. 

  2292.                     /**/ if (tag.equalsIgnoreCase("source"))

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

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

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

  2296.                 }

  2297. 

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

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

  2300.             }

  2301.             break;

  2302.         }

  2303. 

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

  2305. 

  2306.         if (pData->aboutToClose)

  2307.             return true;

  2308.     }

  2309. 

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

  2311.     bool loadExternalConnections;

  2312. 

  2313.     /**/ if (isPlugin)

  2314.         loadExternalConnections = false;

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

  2316.         loadExternalConnections = true;

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

  2318.         loadExternalConnections = false;

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

  2320.         loadExternalConnections = false;

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

  2322.         loadExternalConnections = false;

  2323.     else

  2324.         loadExternalConnections = true;

  2325. 

  2326.     // handle connections (external)

  2327.     if (loadExternalConnections)

  2328.     {

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

  2330. 

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

  2332.         {

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

  2334. 

  2335.             if (! tagName.equalsIgnoreCase("externalpatchbay"))

  2336.                 continue;

  2337. 

  2338.             CarlaString sourcePort, targetPort;

  2339. 

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

  2341.             {

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

  2343. 

  2344.                 sourcePort.clear();

  2345.                 targetPort.clear();

  2346. 

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

  2348.                     continue;

  2349. 

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

  2351.                 {

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

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

  2354. 

  2355.                     /**/ if (tag.equalsIgnoreCase("source"))

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

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

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

  2359.                 }

  2360. 

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

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

  2363.             }

  2364.             break;

  2365.         }

  2366.     }

  2367. #endif

  2368. 

  2369.     return true;

  2370. }

  2371. 

  2372. // -----------------------------------------------------------------------

  2373. 

  2374. CARLA_BACKEND_END_NAMESPACE