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

2324 lines
80KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. /* TODO:

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

  20.  * - implement processPatchbay()

  21.  * - implement oscSend_control_switch_plugins()

  22.  * - 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. #include "juce_core/juce_core.h"

  38. 

  39. using juce::Array;

  40. using juce::CharPointer_UTF8;

  41. using juce::File;

  42. using juce::MemoryOutputStream;

  43. using juce::ScopedPointer;

  44. using juce::String;

  45. using juce::StringArray;

  46. using juce::XmlDocument;

  47. using juce::XmlElement;

  48. 

  49. CARLA_BACKEND_START_NAMESPACE

  50. 

  51. // -----------------------------------------------------------------------

  52. // Carla Engine

  53. 

  54. CarlaEngine::CarlaEngine()

  55.     : pData(new ProtectedData(this))

  56. {

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

  58. }

  59. 

  60. CarlaEngine::~CarlaEngine()

  61. {

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

  63. 

  64.     delete pData;

  65. }

  66. 

  67. // -----------------------------------------------------------------------

  68. // Static calls

  69. 

  70. uint CarlaEngine::getDriverCount()

  71. {

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

  73. 

  74.     uint count = 0;

  75. 

  76.     if (jackbridge_is_ok())

  77.         count += 1;

  78. 

  79. #ifndef BUILD_BRIDGE

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

  81.     count += getJuceApiCount();

  82. # else

  83.     count += getRtAudioApiCount();

  84. # endif

  85. #endif

  86. 

  87.     return count;

  88. }

  89. 

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

  91. {

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

  93. 

  94.     uint index(index2);

  95. 

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

  97.         return "JACK";

  98. 

  99. #ifndef BUILD_BRIDGE

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

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

  102.     {

  103.         if (index < count)

  104.             return getJuceApiName(index);

  105.         index -= count;

  106.     }

  107. # else

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

  109.     {

  110.         if (index < count)

  111.             return getRtAudioApiName(index);

  112.         index -= count;

  113.     }

  114. # endif

  115. #endif

  116. 

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

  118.     return nullptr;

  119. }

  120. 

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

  122. {

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

  124. 

  125.     uint index(index2);

  126. 

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

  128.     {

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

  130.         return ret;

  131.     }

  132. 

  133. #ifndef BUILD_BRIDGE

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

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

  136.     {

  137.         if (index < count)

  138.             return getJuceApiDeviceNames(index);

  139.         index -= count;

  140.     }

  141. # else

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

  143.     {

  144.         if (index < count)

  145.             return getRtAudioApiDeviceNames(index);

  146.         index -= count;

  147.     }

  148. # endif

  149. #endif

  150. 

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

  152.     return nullptr;

  153. }

  154. 

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

  156. {

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

  158. 

  159.     uint index(index2);

  160. 

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

  162.     {

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

  164.         static EngineDriverDeviceInfo devInfo;

  165.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  166.         devInfo.bufferSizes = bufSizes;

  167.         devInfo.sampleRates = nullptr;

  168.         return &devInfo;

  169.     }

  170. 

  171. #ifndef BUILD_BRIDGE

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

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

  174.     {

  175.         if (index < count)

  176.             return getJuceDeviceInfo(index, deviceName);

  177.         index -= count;

  178.     }

  179. # else

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

  181.     {

  182.         if (index < count)

  183.             return getRtAudioDeviceInfo(index, deviceName);

  184.         index -= count;

  185.     }

  186. # endif

  187. #endif

  188. 

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

  190.     return nullptr;

  191. }

  192. 

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

  194. {

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

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

  197. 

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

  199.         return newJack();

  200. 

  201. #ifndef BUILD_BRIDGE

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

  203.     // -------------------------------------------------------------------

  204.     // macos

  205. 

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

  207.         return newJuce(AUDIO_API_CORE);

  208. 

  209.     // -------------------------------------------------------------------

  210.     // windows

  211. 

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

  213.         return newJuce(AUDIO_API_ASIO);

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

  215.         return newJuce(AUDIO_API_DS);

  216. #else

  217.     // -------------------------------------------------------------------

  218.     // common

  219. 

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

  221.         return newRtAudio(AUDIO_API_JACK);

  222. 

  223.     // -------------------------------------------------------------------

  224.     // linux

  225. 

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

  227.         return newRtAudio(AUDIO_API_ALSA);

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

  229.         return newRtAudio(AUDIO_API_OSS);

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

  231.         return newRtAudio(AUDIO_API_PULSE);

  232. # endif

  233. #endif

  234. 

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

  236.     return nullptr;

  237. }

  238. 

  239. // -----------------------------------------------------------------------

  240. // Constant values

  241. 

  242. uint CarlaEngine::getMaxClientNameSize() const noexcept

  243. {

  244.     return STR_MAX/2;

  245. }

  246. 

  247. uint CarlaEngine::getMaxPortNameSize() const noexcept

  248. {

  249.     return STR_MAX;

  250. }

  251. 

  252. uint CarlaEngine::getCurrentPluginCount() const noexcept

  253. {

  254.     return pData->curPluginCount;

  255. }

  256. 

  257. uint CarlaEngine::getMaxPluginNumber() const noexcept

  258. {

  259.     return pData->maxPluginNumber;

  260. }

  261. 

  262. // -----------------------------------------------------------------------

  263. // Virtual, per-engine type calls

  264. 

  265. bool CarlaEngine::close()

  266. {

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

  268. 

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

  270.     {

  271.         pData->aboutToClose = true;

  272.         removeAllPlugins();

  273.     }

  274. 

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

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

  277.         oscSend_control_exit();

  278. #endif

  279. 

  280.     pData->close();

  281. 

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

  283.     return true;

  284. }

  285. 

  286. bool CarlaEngine::usesConstantBufferSize() const noexcept

  287. {

  288.     return true;

  289. }

  290. 

  291. void CarlaEngine::idle() noexcept

  292. {

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

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

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

  296. 

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

  298.     {

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

  300. 

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

  302.         {

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

  304. 

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

  306.             {

  307.                 try {

  308.                     plugin->uiIdle();

  309.                 } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  310.             }

  311.         }

  312.     }

  313. 

  314. #ifdef HAVE_LIBLO

  315.     pData->osc.idle();

  316. #endif

  317. }

  318. 

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

  320. {

  321.     return new CarlaEngineClient(*this);

  322. }

  323. 

  324. // -----------------------------------------------------------------------

  325. // Plugin management

  326. 

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

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

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

  330. {

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

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

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

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

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

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

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

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

  339. 

  340.     uint id;

  341. 

  342. #ifndef BUILD_BRIDGE

  343.     CarlaPlugin* oldPlugin = nullptr;

  344. 

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

  346.     {

  347.         id = pData->nextPluginId;

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

  349. 

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

  351. 

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

  353.     }

  354.     else

  355. #endif

  356.     {

  357.         id = pData->curPluginCount;

  358. 

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

  360.         {

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

  362.             return false;

  363.         }

  364. 

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

  366.     }

  367. 

  368.     CarlaPlugin::Initializer initializer = {

  369.         this,

  370.         id,

  371.         filename,

  372.         name,

  373.         label,

  374.         uniqueId,

  375.         options

  376.     };

  377. 

  378.     CarlaPlugin* plugin = nullptr;

  379. 

  380. #ifndef BUILD_BRIDGE

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

  382. 

  383.     if (bridgeBinary.isNotEmpty())

  384.     {

  385.         if (btype == BINARY_NATIVE)

  386.         {

  387. # ifdef CARLA_OS_WIN

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

  389. # else

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

  391. # endif

  392.         }

  393.         else

  394.         {

  395.             switch (btype)

  396.             {

  397.             case BINARY_POSIX32:

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

  399.                 break;

  400.             case BINARY_POSIX64:

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

  402.                 break;

  403.             case BINARY_WIN32:

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

  405.                 break;

  406.             case BINARY_WIN64:

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

  408.                 break;

  409.             default:

  410.                 bridgeBinary.clear();

  411.                 break;

  412.             }

  413.         }

  414. 

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

  416.             bridgeBinary.clear();

  417.     }

  418. 

  419.     // Prefer bridges for some specific plugins

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

  421. 

  422. # ifdef CARLA_OS_LINUX

  423.     if (! preferBridges)

  424.     {

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

  426.         {

  427.             if (std::strcmp(label, "http://calf.sourceforge.net/plugins/Analyzer") == 0)

  428.                 preferBridges = true;

  429.             if (std::strcmp(label, "http://calf.sourceforge.net/plugins/Fluidsynth") == 0)

  430.                 preferBridges = true;

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

  432.                 preferBridges = true;

  433.         }

  434. #if 0

  435.         else if (ptype == PLUGIN_VST2)

  436.         {

  437.             /*

  438.             char uniqueIdChars[5] = {

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

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

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

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

  443.                 0

  444.             };

  445.             */

  446. 

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

  448.                 preferBridges = true;

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

  450.                 preferBridges = true;

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

  452.                 preferBridges = true;

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

  454.                 preferBridges = true;

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

  456.                 preferBridges = true;

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

  458.                 preferBridges = true;

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

  460.                 preferBridges = true;

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

  462.                 preferBridges = true;

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

  464.                 preferBridges = true;

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

  466.                 preferBridges = true;

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

  468.                 preferBridges = true;

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

  470.                 preferBridges = true;

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

  472.                 preferBridges = true;

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

  474.                 preferBridges = true;

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

  476.                 preferBridges = true;

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

  478.                 preferBridges = true;

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

  480.                 preferBridges = true;

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

  482.                 preferBridges = true;

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

  484.                 preferBridges = true;

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

  486.                 preferBridges = true;

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

  488.                 preferBridges = true;

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

  490.                 preferBridges = true;

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

  492.                 preferBridges = true;

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

  494.                 preferBridges = true;

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

  496.                 preferBridges = true;

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

  498.                 preferBridges = true;

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

  500.                 preferBridges = true;

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

  502.                 preferBridges = true;

  503.         }

  504. #endif

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

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

  507.         {

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

  509.             if (! pData->loadingProject)

  510.                 pData->firstLinuxSamplerInstance = true;

  511. 

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

  513.             else if (pData->firstLinuxSamplerInstance)

  514.                 pData->firstLinuxSamplerInstance = false;

  515. 

  516.             // now check if bridge is needed

  517.             if (! pData->firstLinuxSamplerInstance)

  518.                 preferBridges = true;

  519.         }

  520.     }

  521. # endif

  522. 

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

  524.     {

  525.         if (bridgeBinary.isNotEmpty())

  526.         {

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

  528.         }

  529. # ifdef CARLA_OS_LINUX

  530.         // fallback to dssi-vst if possible

  531.         else if (btype == BINARY_WIN32 && File("/usr/lib/dssi/dssi-vst.so").existsAsFile())

  532.         {

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

  534.             File file(jfilename);

  535. 

  536.             CarlaString label2(file.getFileName().toRawUTF8());

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

  538. 

  539.             CarlaPlugin::Initializer init2 = {

  540.                 this,

  541.                 id,

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

  543.                 name,

  544.                 label2,

  545.                 uniqueId,

  546.                 options

  547.             };

  548. 

  549.             ScopedEnvVar sev("VST_PATH", file.getParentDirectory().getFullPathName().toRawUTF8());

  550. 

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

  552.         }

  553. # endif

  554.         else

  555.         {

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

  557.             return false;

  558.         }

  559.     }

  560.     else

  561. #endif // ! BUILD_BRIDGE

  562.     {

  563.         bool use16Outs;

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

  565. 

  566.         switch (ptype)

  567.         {

  568.         case PLUGIN_NONE:

  569.             break;

  570. 

  571.         case PLUGIN_INTERNAL:

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

  573.             {

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

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

  576.             }

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

  578.             {

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

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

  581.             }

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

  583.             {

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

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

  586.             }

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

  588.             {

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

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

  591.             }*/

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

  593.             break;

  594. 

  595.         case PLUGIN_LADSPA:

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

  597.             break;

  598. 

  599.         case PLUGIN_DSSI:

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

  601.             {

  602.                 const ScopedEngineEnvironmentLocker _seel(this);

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

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

  605.             }

  606.             else

  607.             {

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

  609.             }

  610.             break;

  611. 

  612.         case PLUGIN_LV2:

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

  614.             break;

  615. 

  616.         case PLUGIN_VST2:

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

  618.             break;

  619. 

  620.         case PLUGIN_VST3:

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

  622.             break;

  623. 

  624.         case PLUGIN_AU:

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

  626.             break;

  627. 

  628.         case PLUGIN_GIG:

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

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

  631.             break;

  632. 

  633.         case PLUGIN_SF2:

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

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

  636.             break;

  637. 

  638.         case PLUGIN_SFZ:

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

  640.             break;

  641.         }

  642.     }

  643. 

  644.     if (plugin == nullptr)

  645.         return false;

  646. 

  647.     plugin->reload();

  648. 

  649.     bool canRun = true;

  650. 

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

  652.     {

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

  654.         {

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

  656.             canRun = false;

  657.         }

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

  659.         {

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

  661.             canRun = false;

  662.         }

  663.     }

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

  665.     {

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

  667.         {

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

  669.             canRun = false;

  670.         }

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

  672.         {

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

  674.             canRun = false;

  675.         }

  676.     }

  677. 

  678.     if (! canRun)

  679.     {

  680.         delete plugin;

  681.         return false;

  682.     }

  683. 

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

  685.     plugin->registerToOscClient();

  686. #endif

  687. 

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

  689.     pluginData.plugin      = plugin;

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

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

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

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

  694. 

  695. #ifndef BUILD_BRIDGE

  696.     if (oldPlugin != nullptr)

  697.     {

  698.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  699. 

  700.         const ScopedThreadStopper sts(this);

  701. 

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

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

  704. 

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

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

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

  708. 

  709.         delete oldPlugin;

  710. 

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

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

  713. 

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

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

  716. 

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

  718. 

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

  720.     }

  721.     else if (! pData->loadingProject)

  722. #endif

  723.     {

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

  725.         plugin->setEnabled(true);

  726. 

  727.         ++pData->curPluginCount;

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

  729. 

  730. #ifndef BUILD_BRIDGE

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

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

  733. #endif

  734.     }

  735. 

  736.     return true;

  737. }

  738. 

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

  740. {

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

  742. }

  743. 

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

  745. {

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

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

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

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

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

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

  752. 

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

  754. 

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

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

  757. 

  758.     const ScopedThreadStopper sts(this);

  759. 

  760. #ifndef BUILD_BRIDGE

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

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

  763. 

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

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

  766. 

  767.     /*

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

  769.     {

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

  771.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  772.         plugin2->updateOscURL();

  773.     }

  774.     */

  775. 

  776. # ifdef HAVE_LIBLO

  777.     if (isOscControlRegistered())

  778.         oscSend_control_remove_plugin(id);

  779. # endif

  780. #else

  781.     pData->curPluginCount = 0;

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

  783. #endif

  784. 

  785.     delete plugin;

  786. 

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

  788.     return true;

  789. }

  790. 

  791. bool CarlaEngine::removeAllPlugins()

  792. {

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

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

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

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

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

  798. 

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

  800.         return true;

  801. 

  802.     const ScopedThreadStopper sts(this);

  803. 

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

  805. 

  806. #ifndef BUILD_BRIDGE

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

  808.         pData->graph.removeAllPlugins();

  809. 

  810. # ifdef HAVE_LIBLO

  811.     if (isOscControlRegistered())

  812.     {

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

  814.             oscSend_control_remove_plugin(curPluginCount-i-1);

  815.     }

  816. # endif

  817. #endif

  818. 

  819.     const bool lockWait(isRunning());

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

  821. 

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

  823. 

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

  825.     {

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

  827. 

  828.         if (pluginData.plugin != nullptr)

  829.         {

  830.             delete pluginData.plugin;

  831.             pluginData.plugin = nullptr;

  832.         }

  833. 

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

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

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

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

  838. 

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

  840.     }

  841. 

  842.     return true;

  843. }

  844. 

  845. #ifndef BUILD_BRIDGE

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

  847. {

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

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

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

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

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

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

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

  855. 

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

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

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

  859. 

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

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

  862. 

  863.     plugin->setName(uniqueName);

  864. 

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

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

  867. 

  868.     delete[] uniqueName;

  869.     return plugin->getName();

  870. }

  871. 

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

  873. {

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

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

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

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

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

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

  880. 

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

  882. 

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

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

  885. 

  886.     char label[STR_MAX+1];

  887.     carla_zeroChars(label, STR_MAX+1);

  888.     plugin->getLabel(label);

  889. 

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

  891. 

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

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

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

  895.         return false;

  896. 

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

  898. 

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

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

  901. 

  902.     return true;

  903. }

  904. 

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

  906. {

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

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

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

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

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

  912. 

  913.     // might use this to reset

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

  915.     {

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

  917.         return true;

  918.     }

  919. 

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

  921. 

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

  923. 

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

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

  926. 

  927.     pData->nextPluginId = id;

  928. 

  929.     return true;

  930. }

  931. 

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

  933. {

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

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

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

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

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

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

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

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

  942. 

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

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

  945. 

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

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

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

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

  950. 

  951.     const ScopedThreadStopper sts(this);

  952. 

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

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

  955. 

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

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

  958. 

  959.     // TODO

  960.     /*

  961.     pluginA->updateOscURL();

  962.     pluginB->updateOscURL();

  963. 

  964.     if (isOscControlRegistered())

  965.         oscSend_control_switch_plugins(idA, idB);

  966.     */

  967. 

  968.     return true;

  969. }

  970. #endif

  971. 

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

  973. {

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

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

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

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

  978. 

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

  980. }

  981. 

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

  983. {

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

  985. }

  986. 

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

  988. {

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

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

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

  992. 

  993.     CarlaString sname;

  994.     sname = name;

  995. 

  996.     if (sname.isEmpty())

  997.     {

  998.         sname = "(No name)";

  999.         return sname.dup();

  1000.     }

  1001. 

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

  1003. 

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

  1005.         return sname.dup();

  1006. 

  1007.     sname.truncate(maxNameSize);

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

  1009. 

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

  1011.     {

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

  1013. 

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

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

  1016.         {

  1017.             if (sname != pluginName)

  1018.                 continue;

  1019.         }

  1020. 

  1021.         // Check if string has already been modified

  1022.         {

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

  1024. 

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

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

  1027.             {

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

  1029. 

  1030.                 if (number == 9)

  1031.                 {

  1032.                     // next number is 10, 2 digits

  1033.                     sname.truncate(len-4);

  1034.                     sname += " (10)";

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

  1036.                 }

  1037.                 else

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

  1039. 

  1040.                 continue;

  1041.             }

  1042. 

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

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

  1045.             {

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

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

  1048. 

  1049.                 if (n2 == '9')

  1050.                 {

  1051.                     n2 = '0';

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

  1053.                 }

  1054.                 else

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

  1056. 

  1057.                 sname[len-2] = n2;

  1058.                 sname[len-3] = n3;

  1059. 

  1060.                 continue;

  1061.             }

  1062.         }

  1063. 

  1064.         // Modify string if not

  1065.         sname += " (2)";

  1066.     }

  1067. 

  1068.     return sname.dup();

  1069. }

  1070. 

  1071. // -----------------------------------------------------------------------

  1072. // Project management

  1073. 

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

  1075. {

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

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

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

  1079. 

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

  1081.     File file(jfilename);

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

  1083. 

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

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

  1086. 

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

  1088. 

  1089.     // -------------------------------------------------------------------

  1090. 

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

  1092.         return loadProject(filename);

  1093. 

  1094.     // -------------------------------------------------------------------

  1095. 

  1096.     if (extension == "gig")

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

  1098. 

  1099.     if (extension == "sf2")

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

  1101. 

  1102.     if (extension == "sfz")

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

  1104. 

  1105.     // -------------------------------------------------------------------

  1106. 

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

  1108.     {

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

  1110.         {

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

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

  1113.             return true;

  1114.         }

  1115.         return false;

  1116.     }

  1117. 

  1118.     // -------------------------------------------------------------------

  1119. 

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

  1121.     {

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

  1123.         {

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

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

  1126.             return true;

  1127.         }

  1128.         return false;

  1129.     }

  1130. 

  1131.     // -------------------------------------------------------------------

  1132.     // ZynAddSubFX

  1133. 

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

  1135.     {

  1136. #ifdef HAVE_ZYN_DEPS

  1137.         CarlaString nicerName("Zyn - ");

  1138. 

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

  1140. 

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

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

  1143.         else

  1144.             nicerName += baseName;

  1145. 

  1146.         //nicerName

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

  1148.         {

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

  1150. 

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

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

  1153.             return true;

  1154.         }

  1155.         return false;

  1156. #else

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

  1158.         return false;

  1159. #endif

  1160.     }

  1161. 

  1162.     // -------------------------------------------------------------------

  1163. 

  1164.     setLastError("Unknown file extension");

  1165.     return false;

  1166. }

  1167. 

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

  1169. {

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

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

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

  1173. 

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

  1175.     File file(jfilename);

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

  1177. 

  1178.     XmlDocument xml(file);

  1179.     return loadProjectInternal(xml);

  1180. }

  1181. 

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

  1183. {

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

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

  1186. 

  1187.     MemoryOutputStream out;

  1188.     saveProjectInternal(out);

  1189. 

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

  1191.     File file(jfilename);

  1192. 

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

  1194.         return true;

  1195. 

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

  1197.     return false;

  1198. }

  1199. 

  1200. // -----------------------------------------------------------------------

  1201. // Information (base)

  1202. 

  1203. uint CarlaEngine::getHints() const noexcept

  1204. {

  1205.     return pData->hints;

  1206. }

  1207. 

  1208. uint32_t CarlaEngine::getBufferSize() const noexcept

  1209. {

  1210.     return pData->bufferSize;

  1211. }

  1212. 

  1213. double CarlaEngine::getSampleRate() const noexcept

  1214. {

  1215.     return pData->sampleRate;

  1216. }

  1217. 

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

  1219. {

  1220.     return pData->name;

  1221. }

  1222. 

  1223. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1224. {

  1225.     return pData->options.processMode;

  1226. }

  1227. 

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

  1229. {

  1230.     return pData->options;

  1231. }

  1232. 

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

  1234. {

  1235.     return pData->timeInfo;

  1236. }

  1237. 

  1238. // -----------------------------------------------------------------------

  1239. // Information (peaks)

  1240. 

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

  1242. {

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

  1244. 

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

  1246. }

  1247. 

  1248. float CarlaEngine::getOutputPeak(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].outsPeak[isLeft ? 0 : 1];

  1253. }

  1254. 

  1255. // -----------------------------------------------------------------------

  1256. // Callback

  1257. 

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

  1259. {

  1260. #ifdef DEBUG

  1261.     if (action != ENGINE_CALLBACK_IDLE)

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

  1263. #endif

  1264. 

  1265. #ifdef BUILD_BRIDGE

  1266.     if (pData->isIdling)

  1267. #else

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

  1269. #endif

  1270.     {

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

  1272.     }

  1273. 

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

  1275.     {

  1276.         if (action == ENGINE_CALLBACK_IDLE)

  1277.             ++pData->isIdling;

  1278. 

  1279.         try {

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

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

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

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

  1284.             throw;

  1285. #endif

  1286.         } catch (...) {

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

  1288.         }

  1289. 

  1290.         if (action == ENGINE_CALLBACK_IDLE)

  1291.             --pData->isIdling;

  1292.     }

  1293. }

  1294. 

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

  1296. {

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

  1298. 

  1299.     pData->callback    = func;

  1300.     pData->callbackPtr = ptr;

  1301. }

  1302. 

  1303. // -----------------------------------------------------------------------

  1304. // File Callback

  1305. 

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

  1307. {

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

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

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

  1311. 

  1312.     const char* ret = nullptr;

  1313. 

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

  1315.     {

  1316.         try {

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

  1318.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1319.     }

  1320. 

  1321.     return ret;

  1322. }

  1323. 

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

  1325. {

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

  1327. 

  1328.     pData->fileCallback    = func;

  1329.     pData->fileCallbackPtr = ptr;

  1330. }

  1331. 

  1332. // -----------------------------------------------------------------------

  1333. // Transport

  1334. 

  1335. void CarlaEngine::transportPlay() noexcept

  1336. {

  1337.     pData->time.playing = true;

  1338. }

  1339. 

  1340. void CarlaEngine::transportPause() noexcept

  1341. {

  1342.     pData->time.playing = false;

  1343. }

  1344. 

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

  1346. {

  1347.     pData->time.frame = frame;

  1348. }

  1349. 

  1350. // -----------------------------------------------------------------------

  1351. // Error handling

  1352. 

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

  1354. {

  1355.     return pData->lastError;

  1356. }

  1357. 

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

  1359. {

  1360.     pData->lastError = error;

  1361. }

  1362. 

  1363. // -----------------------------------------------------------------------

  1364. // Misc

  1365. 

  1366. bool CarlaEngine::isAboutToClose() const noexcept

  1367. {

  1368.     return pData->aboutToClose;

  1369. }

  1370. 

  1371. bool CarlaEngine::setAboutToClose() noexcept

  1372. {

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

  1374. 

  1375.     pData->aboutToClose = true;

  1376. 

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

  1378. }

  1379. 

  1380. // -----------------------------------------------------------------------

  1381. // Global options

  1382. 

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

  1384. {

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

  1386. 

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

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

  1389. 

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

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

  1392.         return;

  1393. 

  1394.     switch (option)

  1395.     {

  1396.     case ENGINE_OPTION_DEBUG:

  1397.         break;

  1398. 

  1399.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1402.         break;

  1403. 

  1404.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1407.         break;

  1408. 

  1409.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1412.         break;

  1413. 

  1414.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1415. #ifdef BUILD_BRIDGE

  1416.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1417. #else

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

  1419. #endif

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

  1421.         break;

  1422. 

  1423.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1426.         break;

  1427. 

  1428.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1431.         break;

  1432. 

  1433.     case ENGINE_OPTION_MAX_PARAMETERS:

  1434.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1436.         break;

  1437. 

  1438.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1439.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1441.         break;

  1442. 

  1443.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1446.         break;

  1447. 

  1448.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1449.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1451.         break;

  1452. 

  1453.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1454.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1456.         break;

  1457. 

  1458.     case ENGINE_OPTION_AUDIO_DEVICE:

  1459.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1460. 

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

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

  1463. 

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

  1465.         break;

  1466. 

  1467.     case ENGINE_OPTION_PLUGIN_PATH:

  1468.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1469.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1470. 

  1471.         switch (value)

  1472.         {

  1473.         case PLUGIN_LADSPA:

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

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

  1476.             if (valueStr != nullptr)

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

  1478.             else

  1479.                 pData->options.pathLADSPA = nullptr;

  1480.             break;

  1481.         case PLUGIN_DSSI:

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

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

  1484.             if (valueStr != nullptr)

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

  1486.             else

  1487.                 pData->options.pathDSSI = nullptr;

  1488.             break;

  1489.         case PLUGIN_LV2:

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

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

  1492.             if (valueStr != nullptr)

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

  1494.             else

  1495.                 pData->options.pathLV2 = nullptr;

  1496.             break;

  1497.         case PLUGIN_VST2:

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

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

  1500.             if (valueStr != nullptr)

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

  1502.             else

  1503.                 pData->options.pathVST2 = nullptr;

  1504.             break;

  1505.         case PLUGIN_VST3:

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

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

  1508.             if (valueStr != nullptr)

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

  1510.             else

  1511.                 pData->options.pathVST3 = nullptr;

  1512.             break;

  1513.         case PLUGIN_GIG:

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

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

  1516.             if (valueStr != nullptr)

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

  1518.             else

  1519.                 pData->options.pathGIG = nullptr;

  1520.             break;

  1521.         case PLUGIN_SF2:

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

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

  1524.             if (valueStr != nullptr)

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

  1526.             else

  1527.                 pData->options.pathSF2 = nullptr;

  1528.             break;

  1529.         case PLUGIN_SFZ:

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

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

  1532.             if (valueStr != nullptr)

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

  1534.             else

  1535.                 pData->options.pathSFZ = nullptr;

  1536.             break;

  1537.         default:

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

  1539.             break;

  1540.         }

  1541.         break;

  1542. 

  1543.     case ENGINE_OPTION_PATH_BINARIES:

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

  1545. 

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

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

  1548. 

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

  1550.         break;

  1551. 

  1552.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1554. 

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

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

  1557. 

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

  1559.         break;

  1560. 

  1561.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

  1563. #ifdef CARLA_OS_LINUX

  1564.         if (value != 0)

  1565.         {

  1566.             CarlaString interposerPath(CarlaString(pData->options.binaryDir) + CARLA_OS_SEP_STR "libcarla_interposer.so");

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

  1568.         }

  1569.         else

  1570.         {

  1571.             ::unsetenv("LD_PRELOAD");

  1572.         }

  1573. #endif

  1574.         break;

  1575. 

  1576.     case ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1579.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1581.         break;

  1582.     }

  1583. }

  1584. 

  1585. #ifdef HAVE_LIBLO

  1586. // -----------------------------------------------------------------------

  1587. // OSC Stuff

  1588. 

  1589. # ifndef BUILD_BRIDGE

  1590. bool CarlaEngine::isOscControlRegistered() const noexcept

  1591. {

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

  1593. }

  1594. # endif

  1595. 

  1596. void CarlaEngine::idleOsc() const noexcept

  1597. {

  1598.     pData->osc.idle();

  1599. }

  1600. 

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

  1602. {

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

  1604. }

  1605. 

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

  1607. {

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

  1609. }

  1610. #endif

  1611. 

  1612. // -----------------------------------------------------------------------

  1613. // Helper functions

  1614. 

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

  1616. {

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

  1618. }

  1619. 

  1620. // -----------------------------------------------------------------------

  1621. // Internal stuff

  1622. 

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

  1624. {

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

  1626. 

  1627. #ifndef BUILD_BRIDGE

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

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

  1630.     {

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

  1632.     }

  1633. #endif

  1634. 

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

  1636.     {

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

  1638. 

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

  1640.             plugin->bufferSizeChanged(newBufferSize);

  1641.     }

  1642. 

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

  1644. }

  1645. 

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

  1647. {

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

  1649. 

  1650. #ifndef BUILD_BRIDGE

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

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

  1653.     {

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

  1655.     }

  1656. #endif

  1657. 

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

  1659.     {

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

  1661. 

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

  1663.             plugin->sampleRateChanged(newSampleRate);

  1664.     }

  1665. 

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

  1667. }

  1668. 

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

  1670. {

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

  1672. 

  1673. #ifndef BUILD_BRIDGE

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

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

  1676.     {

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

  1678.     }

  1679. #endif

  1680. 

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

  1682.     {

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

  1684. 

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

  1686.             plugin->offlineModeChanged(isOfflineNow);

  1687.     }

  1688. }

  1689. 

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

  1691. {

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

  1693. 

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

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

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

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

  1698. }

  1699. 

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

  1701. {

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

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

  1704.     {

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

  1706. 

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

  1708.         {

  1709. #ifndef BUILD_BRIDGE

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

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

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

  1713. #endif

  1714.             plugin->prepareForSave();

  1715.         }

  1716.     }

  1717. 

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

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

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

  1721. 

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

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

  1724. 

  1725.     MemoryOutputStream outSettings(1024);

  1726. 

  1727.     // save appropriate engine settings

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

  1729. 

  1730.     //processMode

  1731.     //transportMode

  1732. 

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

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

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

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

  1737. 

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

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

  1740. 

  1741.     if (isPlugin)

  1742.     {

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

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

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

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

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

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

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

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

  1751.     }

  1752. 

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

  1754.     outStream << outSettings;

  1755. 

  1756.     char strBuf[STR_MAX+1];

  1757. 

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

  1759.     {

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

  1761. 

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

  1763.         {

  1764.             MemoryOutputStream outPlugin(4096), streamPlugin;

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

  1766. 

  1767.             outPlugin << "\n";

  1768. 

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

  1770.             plugin->getRealName(strBuf);

  1771. 

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

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

  1774. 

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

  1776.             outPlugin << streamPlugin;

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

  1778.             outStream << outPlugin;

  1779.         }

  1780.     }

  1781. 

  1782. #ifndef BUILD_BRIDGE

  1783.     // tell bridges we're done saving

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

  1785.     {

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

  1787. 

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

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

  1790.     }

  1791. 

  1792.     // save internal connections

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

  1794.     {

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

  1796.         {

  1797.             MemoryOutputStream outPatchbay(2048);

  1798. 

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

  1800. 

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

  1802.             {

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

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

  1805. 

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

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

  1808. 

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

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

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

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

  1813.             }

  1814. 

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

  1816.             outStream << outPatchbay;

  1817.         }

  1818.     }

  1819. 

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

  1821.     bool saveExternalConnections;

  1822. 

  1823.     /**/ if (isPlugin)

  1824.         saveExternalConnections = false;

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

  1826.         saveExternalConnections = true;

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

  1828.         saveExternalConnections = false;

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

  1830.         saveExternalConnections = false;

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

  1832.         saveExternalConnections = false;

  1833.     else

  1834.         saveExternalConnections = true;

  1835. 

  1836.     if (saveExternalConnections)

  1837.     {

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

  1839.         {

  1840.             MemoryOutputStream outPatchbay(2048);

  1841. 

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

  1843. 

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

  1845.             {

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

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

  1848. 

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

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

  1851. 

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

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

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

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

  1856.             }

  1857. 

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

  1859.             outStream << outPatchbay;

  1860.         }

  1861.     }

  1862. #endif

  1863. 

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

  1865. }

  1866. 

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

  1868. {

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

  1870. 

  1871.     // try direct filename first

  1872.     String jbinary(binary);

  1873. 

  1874.     // adjust for current platform

  1875. #ifdef CARLA_OS_WIN

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

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

  1878. #else

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

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

  1881. #endif

  1882. 

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

  1884. 

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

  1886. #ifdef CARLA_OS_MAC

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

  1888.         searchFlags |= File::findDirectories;

  1889. #endif

  1890. 

  1891.     Array<File> results;

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

  1893.     {

  1894.         const File path(*it);

  1895. 

  1896.         results.clear();

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

  1898. 

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

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

  1901.     }

  1902. 

  1903.     // try changing extension

  1904. #if defined(CARLA_OS_MAC)

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

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

  1907. #elif defined(CARLA_OS_WIN)

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

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

  1910. #else

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

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

  1913. #endif

  1914.     else

  1915.         return String();

  1916. 

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

  1918.     {

  1919.         const File path(*it);

  1920. 

  1921.         results.clear();

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

  1923. 

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

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

  1926.     }

  1927. 

  1928.     return String();

  1929. }

  1930. 

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

  1932. {

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

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

  1935. 

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

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

  1938. 

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

  1940.     {

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

  1942.         return false;

  1943.     }

  1944. 

  1945. #ifndef BUILD_BRIDGE

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

  1947. #endif

  1948. 

  1949.     // completely load file

  1950.     xmlElement = xmlDoc.getDocumentElement(false);

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

  1952. 

  1953.     if (pData->aboutToClose)

  1954.         return true;

  1955. 

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

  1957. 

  1958.     // engine settings

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

  1960.     {

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

  1962. 

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

  1964.             continue;

  1965. 

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

  1967.         {

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

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

  1970. 

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

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

  1973. 

  1974.            int option = -1;

  1975.            int value  = 0;

  1976.            const char* valueStr = nullptr;

  1977. 

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

  1979.             {

  1980.                 option = ENGINE_OPTION_FORCE_STEREO;

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

  1982.             }

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

  1984.             {

  1985.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

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

  1987.             }

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

  1989.             {

  1990.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

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

  1992.             }

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

  1994.             {

  1995.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

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

  1997.             }

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

  1999.             {

  2000.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2001.                 value  = text.getIntValue();

  2002.             }

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

  2004.             {

  2005.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2006.                 value  = text.getIntValue();

  2007.             }

  2008.             else if (isPlugin)

  2009.             {

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

  2011.                 {

  2012.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2013.                     value    = PLUGIN_LADSPA;

  2014.                     valueStr = text.toRawUTF8();

  2015.                 }

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

  2017.                 {

  2018.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2019.                     value    = PLUGIN_DSSI;

  2020.                     valueStr = text.toRawUTF8();

  2021.                 }

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

  2023.                 {

  2024.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2025.                     value    = PLUGIN_LV2;

  2026.                     valueStr = text.toRawUTF8();

  2027.                 }

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

  2029.                 {

  2030.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2031.                     value    = PLUGIN_VST2;

  2032.                     valueStr = text.toRawUTF8();

  2033.                 }

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

  2035.                 {

  2036.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2037.                     value    = PLUGIN_VST3;

  2038.                     valueStr = text.toRawUTF8();

  2039.                 }

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

  2041.                 {

  2042.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2043.                     value    = PLUGIN_GIG;

  2044.                     valueStr = text.toRawUTF8();

  2045.                 }

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

  2047.                 {

  2048.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2049.                     value    = PLUGIN_SF2;

  2050.                     valueStr = text.toRawUTF8();

  2051.                 }

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

  2053.                 {

  2054.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2055.                     value    = PLUGIN_SFZ;

  2056.                     valueStr = text.toRawUTF8();

  2057.                 }

  2058.             }

  2059. 

  2060.             CARLA_SAFE_ASSERT_CONTINUE(option != -1);

  2061. 

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

  2063.         }

  2064. 

  2065.         break;

  2066.     }

  2067. 

  2068.     if (pData->aboutToClose)

  2069.         return true;

  2070. 

  2071.     // handle plugins first

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

  2073.     {

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

  2075. 

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

  2077.         {

  2078.             CarlaStateSave stateSave;

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

  2080. 

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

  2082. 

  2083.             if (pData->aboutToClose)

  2084.                 return true;

  2085. 

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

  2087. 

  2088.             const void* extraStuff    = nullptr;

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

  2090. 

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

  2092. 

  2093.             switch (ptype)

  2094.             {

  2095.             case PLUGIN_GIG:

  2096.             case PLUGIN_SF2:

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

  2098.                     extraStuff = kTrue;

  2099.                 // nobreak

  2100.             case PLUGIN_LADSPA:

  2101.             case PLUGIN_DSSI:

  2102.             case PLUGIN_VST2:

  2103.             case PLUGIN_VST3:

  2104.             case PLUGIN_SFZ:

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

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

  2107.                 {

  2108.                     const char* searchPath;

  2109. 

  2110.                     switch (ptype)

  2111.                     {

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

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

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

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

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

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

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

  2119.                     default:            searchPath = nullptr;                   break;

  2120.                     }

  2121. 

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

  2123.                     {

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

  2125.                                      stateSave.binary);

  2126. 

  2127.                         const String result(findBinaryInCustomPath(searchPath, stateSave.binary));

  2128. 

  2129.                         if (result.isNotEmpty())

  2130.                         {

  2131.                             delete[] stateSave.binary;

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

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

  2134.                         }

  2135.                         else

  2136.                         {

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

  2138.                         }

  2139.                     }

  2140.                 }

  2141.                 break;

  2142.             default:

  2143.                 break;

  2144.             }

  2145. 

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

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

  2148.             {

  2149.                 const uint pluginId = pData->curPluginCount;

  2150. 

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

  2152.                 {

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

  2154. 

  2155.                     if (pData->aboutToClose)

  2156.                         return true;

  2157. 

  2158. #ifndef BUILD_BRIDGE

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

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

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

  2162. #endif

  2163.                     plugin->loadStateSave(stateSave);

  2164. 

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

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

  2167.                      *        as we want to load state first.

  2168.                      */

  2169. #ifdef BUILD_BRIDGE

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

  2171. #endif

  2172.                     plugin->setEnabled(true);

  2173. 

  2174.                     ++pData->curPluginCount;

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

  2176. 

  2177. #ifndef BUILD_BRIDGE

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

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

  2180. #endif

  2181.                 }

  2182.                 else

  2183.                 {

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

  2185.                 }

  2186.             }

  2187.             else

  2188.             {

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

  2190.             }

  2191.         }

  2192. 

  2193.         if (isPreset)

  2194.             return true;

  2195.     }

  2196. 

  2197. #ifndef BUILD_BRIDGE

  2198.     // tell bridges we're done loading

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

  2200.     {

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

  2202. 

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

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

  2205.     }

  2206. 

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

  2208. 

  2209.     if (pData->aboutToClose)

  2210.         return true;

  2211. 

  2212.     // handle connections (internal)

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

  2214.     {

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

  2216. 

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

  2218.         {

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

  2220. 

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

  2222.                 continue;

  2223. 

  2224.             CarlaString sourcePort, targetPort;

  2225. 

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

  2227.             {

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

  2229. 

  2230.                 sourcePort.clear();

  2231.                 targetPort.clear();

  2232. 

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

  2234.                     continue;

  2235. 

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

  2237.                 {

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

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

  2240. 

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

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

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

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

  2245.                 }

  2246. 

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

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

  2249.             }

  2250.             break;

  2251.         }

  2252. 

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

  2254. 

  2255.         if (pData->aboutToClose)

  2256.             return true;

  2257.     }

  2258. 

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

  2260.     bool loadExternalConnections;

  2261. 

  2262.     /**/ if (isPlugin)

  2263.         loadExternalConnections = false;

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

  2265.         loadExternalConnections = true;

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

  2267.         loadExternalConnections = false;

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

  2269.         loadExternalConnections = false;

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

  2271.         loadExternalConnections = false;

  2272.     else

  2273.         loadExternalConnections = true;

  2274. 

  2275.     // handle connections (external)

  2276.     if (loadExternalConnections)

  2277.     {

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

  2279. 

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

  2281.         {

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

  2283. 

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

  2285.                 continue;

  2286. 

  2287.             CarlaString sourcePort, targetPort;

  2288. 

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

  2290.             {

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

  2292. 

  2293.                 sourcePort.clear();

  2294.                 targetPort.clear();

  2295. 

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

  2297.                     continue;

  2298. 

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

  2300.                 {

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

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

  2303. 

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

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

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

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

  2308.                 }

  2309. 

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

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

  2312.             }

  2313.             break;

  2314.         }

  2315.     }

  2316. #endif

  2317. 

  2318.     return true;

  2319. }

  2320. 

  2321. // -----------------------------------------------------------------------

  2322. 

  2323. CARLA_BACKEND_END_NAMESPACE