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

2412 lines
83KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. /* TODO:

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

  20.  * - implement processPatchbay()

  21.  * - implement oscSend_control_switch_plugins()

  22.  * - something about the peaks?

  23.  */

  24. 

  25. #include "CarlaEngineInternal.hpp"

  26. #include "CarlaPlugin.hpp"

  27. 

  28. #include "CarlaBackendUtils.hpp"

  29. #include "CarlaBinaryUtils.hpp"

  30. #include "CarlaEngineUtils.hpp"

  31. #include "CarlaMathUtils.hpp"

  32. #include "CarlaPipeUtils.hpp"

  33. #include "CarlaStateUtils.hpp"

  34. #include "CarlaMIDI.h"

  35. 

  36. #include "jackbridge/JackBridge.hpp"

  37. 

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

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

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

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

  42. 

  43. using water::Array;

  44. using water::CharPointer_UTF8;

  45. using water::File;

  46. using water::MemoryOutputStream;

  47. using water::String;

  48. using water::StringArray;

  49. using water::XmlDocument;

  50. using water::XmlElement;

  51. 

  52. CARLA_BACKEND_START_NAMESPACE

  53. 

  54. // -----------------------------------------------------------------------

  55. // Carla Engine

  56. 

  57. CarlaEngine::CarlaEngine()

  58.     : pData(new ProtectedData(this))

  59. {

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

  61. }

  62. 

  63. CarlaEngine::~CarlaEngine()

  64. {

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

  66. 

  67.     delete pData;

  68. }

  69. 

  70. // -----------------------------------------------------------------------

  71. // Static calls

  72. 

  73. uint CarlaEngine::getDriverCount()

  74. {

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

  76. 

  77.     uint count = 0;

  78. 

  79.     if (jackbridge_is_ok())

  80.         count += 1;

  81. 

  82. #ifndef BUILD_BRIDGE

  83.     count += getRtAudioApiCount();

  84. #endif

  85. 

  86.     return count;

  87. }

  88. 

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

  90. {

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

  92. 

  93.     uint index(index2);

  94. 

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

  96.         return "JACK";

  97. 

  98. #ifndef BUILD_BRIDGE

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

  100.     {

  101.         if (index < count)

  102.             return getRtAudioApiName(index);

  103.     }

  104. #endif

  105. 

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

  107.     return nullptr;

  108. }

  109. 

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

  111. {

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

  113. 

  114.     uint index(index2);

  115. 

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

  117.     {

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

  119.         return ret;

  120.     }

  121. 

  122. #ifndef BUILD_BRIDGE

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

  124.     {

  125.         if (index < count)

  126.             return getRtAudioApiDeviceNames(index);

  127.     }

  128. #endif

  129. 

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

  131.     return nullptr;

  132. }

  133. 

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

  135. {

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

  137. 

  138.     uint index(index2);

  139. 

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

  141.     {

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

  143.         static EngineDriverDeviceInfo devInfo;

  144.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  145.         devInfo.bufferSizes = bufSizes;

  146.         devInfo.sampleRates = nullptr;

  147.         return &devInfo;

  148.     }

  149. 

  150. #ifndef BUILD_BRIDGE

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

  152.     {

  153.         if (index < count)

  154.             return getRtAudioDeviceInfo(index, deviceName);

  155.     }

  156. #endif

  157. 

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

  159.     return nullptr;

  160. }

  161. 

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

  163. {

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

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

  166. 

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

  168.         return newJack();

  169. 

  170. #ifndef BUILD_BRIDGE

  171.     // -------------------------------------------------------------------

  172.     // common

  173. 

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

  175.         return newRtAudio(AUDIO_API_NULL);

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

  177.         return newRtAudio(AUDIO_API_JACK);

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

  179.         return newRtAudio(AUDIO_API_OSS);

  180. 

  181.     // -------------------------------------------------------------------

  182.     // linux

  183. 

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

  185.         return newRtAudio(AUDIO_API_ALSA);

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

  187.         return newRtAudio(AUDIO_API_PULSEAUDIO);

  188. 

  189.     // -------------------------------------------------------------------

  190.     // macos

  191. 

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

  193.         return newRtAudio(AUDIO_API_COREAUDIO);

  194. 

  195.     // -------------------------------------------------------------------

  196.     // windows

  197. 

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

  199.         return newRtAudio(AUDIO_API_ASIO);

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

  201.         return newRtAudio(AUDIO_API_DIRECTSOUND);

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

  203.         return newRtAudio(AUDIO_API_WASAPI);

  204. #endif

  205. 

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

  207.     return nullptr;

  208. }

  209. 

  210. // -----------------------------------------------------------------------

  211. // Constant values

  212. 

  213. uint CarlaEngine::getMaxClientNameSize() const noexcept

  214. {

  215.     return STR_MAX/2;

  216. }

  217. 

  218. uint CarlaEngine::getMaxPortNameSize() const noexcept

  219. {

  220.     return STR_MAX;

  221. }

  222. 

  223. uint CarlaEngine::getCurrentPluginCount() const noexcept

  224. {

  225.     return pData->curPluginCount;

  226. }

  227. 

  228. uint CarlaEngine::getMaxPluginNumber() const noexcept

  229. {

  230.     return pData->maxPluginNumber;

  231. }

  232. 

  233. // -----------------------------------------------------------------------

  234. // Virtual, per-engine type calls

  235. 

  236. bool CarlaEngine::close()

  237. {

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

  239. 

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

  241.     {

  242.         pData->aboutToClose = true;

  243.         removeAllPlugins();

  244.     }

  245. 

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

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

  248.         oscSend_control_exit();

  249. #endif

  250. 

  251.     pData->close();

  252. 

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

  254.     return true;

  255. }

  256. 

  257. bool CarlaEngine::usesConstantBufferSize() const noexcept

  258. {

  259.     return true;

  260. }

  261. 

  262. void CarlaEngine::idle() noexcept

  263. {

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

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

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

  267. 

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

  269.     {

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

  271. 

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

  273.         {

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

  275. 

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

  277.             {

  278.                 try {

  279.                     plugin->uiIdle();

  280.                 } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  281.             }

  282.         }

  283.     }

  284. 

  285. #ifdef HAVE_LIBLO

  286.     pData->osc.idle();

  287. #endif

  288. }

  289. 

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

  291. {

  292.     return new CarlaEngineClient(*this);

  293. }

  294. 

  295. // -----------------------------------------------------------------------

  296. // Plugin management

  297. 

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

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

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

  301. {

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

  303. #ifndef BUILD_BRIDGE

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

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

  306. #endif

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

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

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

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

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

  312. 

  313.     uint id;

  314. 

  315. #ifndef BUILD_BRIDGE

  316.     CarlaPlugin* oldPlugin = nullptr;

  317. 

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

  319.     {

  320.         id = pData->nextPluginId;

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

  322. 

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

  324. 

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

  326.     }

  327.     else

  328. #endif

  329.     {

  330.         id = pData->curPluginCount;

  331. 

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

  333.         {

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

  335.             return false;

  336.         }

  337. 

  338. #ifndef BUILD_BRIDGE

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

  340. #endif

  341.     }

  342. 

  343.     CarlaPlugin::Initializer initializer = {

  344.         this,

  345.         id,

  346.         filename,

  347.         name,

  348.         label,

  349.         uniqueId,

  350.         options

  351.     };

  352. 

  353.     CarlaPlugin* plugin = nullptr;

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

  355. 

  356.     if (bridgeBinary.isNotEmpty())

  357.     {

  358. #ifndef CARLA_OS_WIN

  359.         if (btype == BINARY_NATIVE)

  360.         {

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

  362.         }

  363.         else

  364. #endif

  365.         {

  366.             switch (btype)

  367.             {

  368.             case BINARY_POSIX32:

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

  370.                 break;

  371.             case BINARY_POSIX64:

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

  373.                 break;

  374.             case BINARY_WIN32:

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

  376.                 break;

  377.             case BINARY_WIN64:

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

  379.                 break;

  380.             default:

  381.                 bridgeBinary.clear();

  382.                 break;

  383.             }

  384.         }

  385. 

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

  387.             bridgeBinary.clear();

  388.     }

  389. 

  390.     // Prefer bridges for some specific plugins

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

  392. 

  393. #ifndef BUILD_BRIDGE

  394.     if (! preferBridges)

  395.     {

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

  397.         {

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

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

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

  401.             {

  402.                 preferBridges = true;

  403.             }

  404.         }

  405. # if 0

  406.         else if (ptype == PLUGIN_VST2)

  407.         {

  408.             /*

  409.             char uniqueIdChars[5] = {

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

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

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

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

  414.                 0

  415.             };

  416.             */

  417. 

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

  419.                 preferBridges = true;

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

  421.                 preferBridges = true;

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

  423.                 preferBridges = true;

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

  425.                 preferBridges = true;

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

  427.                 preferBridges = true;

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

  429.                 preferBridges = true;

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

  431.                 preferBridges = true;

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

  433.                 preferBridges = true;

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

  435.                 preferBridges = true;

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

  437.                 preferBridges = true;

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

  439.                 preferBridges = true;

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

  441.                 preferBridges = true;

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

  443.                 preferBridges = true;

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

  445.                 preferBridges = true;

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

  447.                 preferBridges = true;

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

  449.                 preferBridges = true;

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

  451.                 preferBridges = true;

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

  453.                 preferBridges = true;

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

  455.                 preferBridges = true;

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

  457.                 preferBridges = true;

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

  459.                 preferBridges = true;

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

  461.                 preferBridges = true;

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

  463.                 preferBridges = true;

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

  465.                 preferBridges = true;

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

  467.                 preferBridges = true;

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

  469.                 preferBridges = true;

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

  471.                 preferBridges = true;

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

  473.                 preferBridges = true;

  474.         }

  475. # endif

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

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

  478.         {

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

  480.             if (! pData->loadingProject)

  481.                 pData->firstLinuxSamplerInstance = true;

  482. 

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

  484.             else if (pData->firstLinuxSamplerInstance)

  485.                 pData->firstLinuxSamplerInstance = false;

  486. 

  487.             // now check if bridge is needed

  488.             if (! pData->firstLinuxSamplerInstance)

  489.                 preferBridges = true;

  490.         }

  491.     }

  492. #endif // ! BUILD_BRIDGE

  493. 

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

  495.     {

  496.         if (bridgeBinary.isNotEmpty())

  497.         {

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

  499.         }

  500.         else

  501.         {

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

  503.             return false;

  504.         }

  505.     }

  506.     else

  507.     {

  508.         bool use16Outs;

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

  510. 

  511.         switch (ptype)

  512.         {

  513.         case PLUGIN_NONE:

  514.             break;

  515. 

  516.         case PLUGIN_INTERNAL:

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

  518.             {

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

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

  521.             }

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

  523.             {

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

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

  526.             }

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

  528.             {

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

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

  531.             }

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

  533.             {

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

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

  536.             }*/

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

  538.             break;

  539. 

  540.         case PLUGIN_LADSPA:

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

  542.             break;

  543. 

  544.         case PLUGIN_DSSI:

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

  546.             break;

  547. 

  548.         case PLUGIN_LV2:

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

  550.             break;

  551. 

  552.         case PLUGIN_VST2:

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

  554.             break;

  555. 

  556.         case PLUGIN_GIG:

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

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

  559.             break;

  560. 

  561.         case PLUGIN_SF2:

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

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

  564.             break;

  565. 

  566.         case PLUGIN_SFZ:

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

  568.             break;

  569. 

  570.         case PLUGIN_JACK:

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

  572.             break;

  573.         }

  574.     }

  575. 

  576.     if (plugin == nullptr)

  577.         return false;

  578. 

  579.     plugin->reload();

  580. 

  581. #ifndef BUILD_BRIDGE

  582.     bool canRun = true;

  583. 

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

  585.     {

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

  587.         {

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

  589.             canRun = false;

  590.         }

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

  592.         {

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

  594.             canRun = false;

  595.         }

  596.     }

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

  598.     {

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

  600.         {

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

  602.             canRun = false;

  603.         }

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

  605.         {

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

  607.             canRun = false;

  608.         }

  609.     }

  610. 

  611.     if (! canRun)

  612.     {

  613.         delete plugin;

  614.         return false;

  615.     }

  616. 

  617. # ifdef HAVE_LIBLO

  618.     plugin->registerToOscClient();

  619. # endif

  620. #endif

  621. 

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

  623.     pluginData.plugin      = plugin;

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

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

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

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

  628. 

  629. #ifndef BUILD_BRIDGE

  630.     if (oldPlugin != nullptr)

  631.     {

  632.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  633. 

  634.         const ScopedThreadStopper sts(this);

  635. 

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

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

  638. 

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

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

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

  642. 

  643.         delete oldPlugin;

  644. 

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

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

  647. 

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

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

  650. 

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

  652.         plugin->setEnabled(true);

  653. 

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

  655.     }

  656.     else if (! pData->loadingProject)

  657. #endif

  658.     {

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

  660.         plugin->setEnabled(true);

  661. 

  662.         ++pData->curPluginCount;

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

  664. 

  665. #ifndef BUILD_BRIDGE

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

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

  668. #endif

  669.     }

  670. 

  671.     return true;

  672. }

  673. 

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

  675. {

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

  677. }

  678. 

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

  680. {

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

  682. #ifndef BUILD_BRIDGE

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

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

  685. #endif

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

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

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

  689. 

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

  691. 

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

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

  694. 

  695.     const ScopedThreadStopper sts(this);

  696. 

  697. #ifndef BUILD_BRIDGE

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

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

  700. 

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

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

  703. 

  704.     /*

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

  706.     {

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

  708.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  709.         plugin2->updateOscURL();

  710.     }

  711.     */

  712. 

  713. # ifdef HAVE_LIBLO

  714.     if (isOscControlRegistered())

  715.         oscSend_control_remove_plugin(id);

  716. # endif

  717. #else

  718.     pData->curPluginCount = 0;

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

  720. #endif

  721. 

  722.     delete plugin;

  723. 

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

  725.     return true;

  726. }

  727. 

  728. bool CarlaEngine::removeAllPlugins()

  729. {

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

  731. #ifndef BUILD_BRIDGE

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

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

  734. #endif

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

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

  737. 

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

  739.         return true;

  740. 

  741.     const ScopedThreadStopper sts(this);

  742. 

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

  744. 

  745. #ifndef BUILD_BRIDGE

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

  747.         pData->graph.removeAllPlugins();

  748. 

  749. # ifdef HAVE_LIBLO

  750.     if (isOscControlRegistered())

  751.     {

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

  753.             oscSend_control_remove_plugin(curPluginCount-i-1);

  754.     }

  755. # endif

  756. #endif

  757. 

  758.     const bool lockWait(isRunning());

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

  760. 

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

  762. 

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

  764.     {

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

  766. 

  767.         if (pluginData.plugin != nullptr)

  768.         {

  769.             delete pluginData.plugin;

  770.             pluginData.plugin = nullptr;

  771.         }

  772. 

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

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

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

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

  777. 

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

  779.     }

  780. 

  781.     return true;

  782. }

  783. 

  784. #ifndef BUILD_BRIDGE

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

  786. {

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

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

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

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

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

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

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

  794. 

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

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

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

  798. 

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

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

  801. 

  802.     plugin->setName(uniqueName);

  803. 

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

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

  806. 

  807.     delete[] uniqueName;

  808.     return plugin->getName();

  809. }

  810. 

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

  812. {

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

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

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

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

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

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

  819. 

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

  821. 

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

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

  824. 

  825.     char label[STR_MAX+1];

  826.     carla_zeroChars(label, STR_MAX+1);

  827.     plugin->getLabel(label);

  828. 

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

  830. 

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

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

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

  834.         return false;

  835. 

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

  837. 

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

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

  840. 

  841.     return true;

  842. }

  843. 

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

  845. {

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

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

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

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

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

  851. 

  852.     // might use this to reset

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

  854.     {

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

  856.         return true;

  857.     }

  858. 

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

  860. 

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

  862. 

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

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

  865. 

  866.     pData->nextPluginId = id;

  867. 

  868.     return true;

  869. }

  870. 

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

  872. {

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

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

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

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

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

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

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

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

  881. 

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

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

  884. 

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

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

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

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

  889. 

  890.     const ScopedThreadStopper sts(this);

  891. 

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

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

  894. 

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

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

  897. 

  898.     // TODO

  899.     /*

  900.     pluginA->updateOscURL();

  901.     pluginB->updateOscURL();

  902. 

  903.     if (isOscControlRegistered())

  904.         oscSend_control_switch_plugins(idA, idB);

  905.     */

  906. 

  907.     return true;

  908. }

  909. #endif

  910. 

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

  912. {

  913. #ifndef BUILD_BRIDGE

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

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

  916. #endif

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

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

  919. 

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

  921. }

  922. 

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

  924. {

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

  926. }

  927. 

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

  929. {

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

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

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

  933. 

  934.     CarlaString sname;

  935.     sname = name;

  936. 

  937.     if (sname.isEmpty())

  938.     {

  939.         sname = "(No name)";

  940.         return sname.dup();

  941.     }

  942. 

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

  944. 

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

  946.         return sname.dup();

  947. 

  948.     sname.truncate(maxNameSize);

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

  950. 

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

  952.     {

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

  954. 

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

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

  957.         {

  958.             if (sname != pluginName)

  959.                 continue;

  960.         }

  961. 

  962.         // Check if string has already been modified

  963.         {

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

  965. 

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

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

  968.             {

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

  970. 

  971.                 if (number == 9)

  972.                 {

  973.                     // next number is 10, 2 digits

  974.                     sname.truncate(len-4);

  975.                     sname += " (10)";

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

  977.                 }

  978.                 else

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

  980. 

  981.                 continue;

  982.             }

  983. 

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

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

  986.             {

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

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

  989. 

  990.                 if (n2 == '9')

  991.                 {

  992.                     n2 = '0';

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

  994.                 }

  995.                 else

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

  997. 

  998.                 sname[len-2] = n2;

  999.                 sname[len-3] = n3;

  1000. 

  1001.                 continue;

  1002.             }

  1003.         }

  1004. 

  1005.         // Modify string if not

  1006.         sname += " (2)";

  1007.     }

  1008. 

  1009.     return sname.dup();

  1010. }

  1011. 

  1012. // -----------------------------------------------------------------------

  1013. // Project management

  1014. 

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

  1016. {

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

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

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

  1020. 

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

  1022.     File file(jfilename);

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

  1024. 

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

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

  1027. 

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

  1029. 

  1030.     // -------------------------------------------------------------------

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

  1032. 

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

  1034.         return loadProject(filename);

  1035. 

  1036.     // -------------------------------------------------------------------

  1037. 

  1038.     if (extension == "gig")

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

  1040. 

  1041.     if (extension == "sf2")

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

  1043. 

  1044.     if (extension == "sfz")

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

  1046. 

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

  1048. 

  1049.     if (

  1050. #ifdef HAVE_SNDFILE

  1051.         extension == "aif"  ||

  1052.         extension == "aiff" ||

  1053.         extension == "bwf"  ||

  1054.         extension == "flac" ||

  1055.         extension == "oga"  ||

  1056.         extension == "ogg"  ||

  1057.         extension == "w64"  ||

  1058.         extension == "wav"  ||

  1059. #endif

  1060. #ifdef HAVE_FFMPEG

  1061.         extension == "3g2" ||

  1062.         extension == "3gp" ||

  1063.         extension == "aac" ||

  1064.         extension == "ac3" ||

  1065.         extension == "amr" ||

  1066.         extension == "ape" ||

  1067.         extension == "mp2" ||

  1068.         extension == "mp3" ||

  1069.         extension == "mpc" ||

  1070.         extension == "wma" ||

  1071. #endif

  1072.         false

  1073.        )

  1074.     {

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

  1076.         {

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

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

  1079.             return true;

  1080.         }

  1081.         return false;

  1082.     }

  1083. 

  1084.     // -------------------------------------------------------------------

  1085. 

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

  1087.     {

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

  1089.         {

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

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

  1092.             return true;

  1093.         }

  1094.         return false;

  1095.     }

  1096. 

  1097.     // -------------------------------------------------------------------

  1098.     // ZynAddSubFX

  1099. 

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

  1101.     {

  1102. #ifdef HAVE_ZYN_DEPS

  1103.         CarlaString nicerName("Zyn - ");

  1104. 

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

  1106. 

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

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

  1109.         else

  1110.             nicerName += baseName;

  1111. 

  1112.         //nicerName

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

  1114.         {

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

  1116. 

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

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

  1119.             return true;

  1120.         }

  1121.         return false;

  1122. #else

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

  1124.         return false;

  1125. #endif

  1126.     }

  1127. 

  1128.     // -------------------------------------------------------------------

  1129.     // Direct plugin binaries

  1130. 

  1131. #ifdef CARLA_OS_MAC

  1132.     if (extension == "vst")

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

  1134. #else

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

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

  1137. #endif

  1138. 

  1139.     // -------------------------------------------------------------------

  1140. 

  1141.     setLastError("Unknown file extension");

  1142.     return false;

  1143. }

  1144. 

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

  1146. {

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

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

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

  1150. 

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

  1152.     File file(jfilename);

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

  1154. 

  1155.     XmlDocument xml(file);

  1156.     return loadProjectInternal(xml);

  1157. }

  1158. 

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

  1160. {

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

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

  1163. 

  1164.     MemoryOutputStream out;

  1165.     saveProjectInternal(out);

  1166. 

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

  1168.     File file(jfilename);

  1169. 

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

  1171.         return true;

  1172. 

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

  1174.     return false;

  1175. }

  1176. 

  1177. // -----------------------------------------------------------------------

  1178. // Information (base)

  1179. 

  1180. uint CarlaEngine::getHints() const noexcept

  1181. {

  1182.     return pData->hints;

  1183. }

  1184. 

  1185. uint32_t CarlaEngine::getBufferSize() const noexcept

  1186. {

  1187.     return pData->bufferSize;

  1188. }

  1189. 

  1190. double CarlaEngine::getSampleRate() const noexcept

  1191. {

  1192.     return pData->sampleRate;

  1193. }

  1194. 

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

  1196. {

  1197.     return pData->name;

  1198. }

  1199. 

  1200. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1201. {

  1202.     return pData->options.processMode;

  1203. }

  1204. 

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

  1206. {

  1207.     return pData->options;

  1208. }

  1209. 

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

  1211. {

  1212.     return pData->timeInfo;

  1213. }

  1214. 

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

  1216. // Information (peaks)

  1217. 

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

  1219. {

  1220.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1221.     {

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

  1223.         if (pData->curPluginCount > 0)

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

  1225.         return 0.0f;

  1226.     }

  1227. 

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

  1229. 

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

  1231. }

  1232. 

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

  1234. {

  1235.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1236.     {

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

  1238.         if (pData->curPluginCount > 0)

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

  1240.         return 0.0f;

  1241.     }

  1242. 

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

  1244. 

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

  1246. }

  1247. 

  1248. // -----------------------------------------------------------------------

  1249. // Callback

  1250. 

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

  1252. {

  1253. #ifdef DEBUG

  1254.     if (action != ENGINE_CALLBACK_IDLE)

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

  1256. #endif

  1257. 

  1258. #ifdef BUILD_BRIDGE

  1259.     if (pData->isIdling)

  1260. #else

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

  1262. #endif

  1263.     {

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

  1265.     }

  1266. 

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

  1268.     {

  1269.         if (action == ENGINE_CALLBACK_IDLE)

  1270.             ++pData->isIdling;

  1271. 

  1272.         try {

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

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

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

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

  1277.             throw;

  1278. #endif

  1279.         } catch (...) {

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

  1281.         }

  1282. 

  1283.         if (action == ENGINE_CALLBACK_IDLE)

  1284.             --pData->isIdling;

  1285.     }

  1286. }

  1287. 

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

  1289. {

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

  1291. 

  1292.     pData->callback    = func;

  1293.     pData->callbackPtr = ptr;

  1294. }

  1295. 

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

  1297. // File Callback

  1298. 

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

  1300. {

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

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

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

  1304. 

  1305.     const char* ret = nullptr;

  1306. 

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

  1308.     {

  1309.         try {

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

  1311.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1312.     }

  1313. 

  1314.     return ret;

  1315. }

  1316. 

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

  1318. {

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

  1320. 

  1321.     pData->fileCallback    = func;

  1322.     pData->fileCallbackPtr = ptr;

  1323. }

  1324. 

  1325. // -----------------------------------------------------------------------

  1326. // Transport

  1327. 

  1328. void CarlaEngine::transportPlay() noexcept

  1329. {

  1330.     pData->timeInfo.playing = true;

  1331.     pData->time.setNeedsReset();

  1332. }

  1333. 

  1334. void CarlaEngine::transportPause() noexcept

  1335. {

  1336.     if (pData->timeInfo.playing)

  1337.         pData->time.pause();

  1338.     else

  1339.         pData->time.setNeedsReset();

  1340. }

  1341. 

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

  1343. {

  1344.     try {

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

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

  1347. }

  1348. 

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

  1350. {

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

  1352. }

  1353. 

  1354. // -----------------------------------------------------------------------

  1355. // Error handling

  1356. 

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

  1358. {

  1359.     return pData->lastError;

  1360. }

  1361. 

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

  1363. {

  1364.     pData->lastError = error;

  1365. }

  1366. 

  1367. // -----------------------------------------------------------------------

  1368. // Misc

  1369. 

  1370. bool CarlaEngine::isAboutToClose() const noexcept

  1371. {

  1372.     return pData->aboutToClose;

  1373. }

  1374. 

  1375. bool CarlaEngine::setAboutToClose() noexcept

  1376. {

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

  1378. 

  1379.     pData->aboutToClose = true;

  1380. 

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

  1382. }

  1383. 

  1384. // -----------------------------------------------------------------------

  1385. // Global options

  1386. 

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

  1388. {

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

  1390. 

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

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

  1393. 

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

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

  1396.         return;

  1397. 

  1398.     switch (option)

  1399.     {

  1400.     case ENGINE_OPTION_DEBUG:

  1401.         break;

  1402. 

  1403.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1406.         break;

  1407. 

  1408.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

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

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

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

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

  1415.         else

  1416.             pData->options.transportExtra = nullptr;

  1417. 

  1418.         pData->time.setNeedsReset();

  1419. 

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

  1421.         // enable link now if needed

  1422.         {

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

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

  1425.         }

  1426. #endif

  1427.         break;

  1428. 

  1429.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1432.         break;

  1433. 

  1434.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1435. #ifdef BUILD_BRIDGE

  1436.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1437. #else

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

  1439. #endif

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

  1441.         break;

  1442. 

  1443.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1446.         break;

  1447. 

  1448.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1451.         break;

  1452. 

  1453.     case ENGINE_OPTION_MAX_PARAMETERS:

  1454.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1456.         break;

  1457. 

  1458.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1459.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1461.         break;

  1462. 

  1463.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1466.         break;

  1467. 

  1468.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1469.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1471.         break;

  1472. 

  1473.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1474.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1476.         break;

  1477. 

  1478.     case ENGINE_OPTION_AUDIO_DEVICE:

  1479.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1480. 

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

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

  1483. 

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

  1485.         break;

  1486. 

  1487.     case ENGINE_OPTION_PLUGIN_PATH:

  1488.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1489.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1490. 

  1491.         switch (value)

  1492.         {

  1493.         case PLUGIN_LADSPA:

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

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

  1496.             if (valueStr != nullptr)

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

  1498.             else

  1499.                 pData->options.pathLADSPA = nullptr;

  1500.             break;

  1501.         case PLUGIN_DSSI:

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

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

  1504.             if (valueStr != nullptr)

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

  1506.             else

  1507.                 pData->options.pathDSSI = nullptr;

  1508.             break;

  1509.         case PLUGIN_LV2:

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

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

  1512.             if (valueStr != nullptr)

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

  1514.             else

  1515.                 pData->options.pathLV2 = nullptr;

  1516.             break;

  1517.         case PLUGIN_VST2:

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

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

  1520.             if (valueStr != nullptr)

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

  1522.             else

  1523.                 pData->options.pathVST2 = nullptr;

  1524.             break;

  1525.         case PLUGIN_GIG:

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

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

  1528.             if (valueStr != nullptr)

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

  1530.             else

  1531.                 pData->options.pathGIG = nullptr;

  1532.             break;

  1533.         case PLUGIN_SF2:

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

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

  1536.             if (valueStr != nullptr)

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

  1538.             else

  1539.                 pData->options.pathSF2 = nullptr;

  1540.             break;

  1541.         case PLUGIN_SFZ:

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

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

  1544.             if (valueStr != nullptr)

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

  1546.             else

  1547.                 pData->options.pathSFZ = nullptr;

  1548.             break;

  1549.         default:

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

  1551.             break;

  1552.         }

  1553.         break;

  1554. 

  1555.     case ENGINE_OPTION_PATH_BINARIES:

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

  1557. 

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

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

  1560. 

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

  1562.         break;

  1563. 

  1564.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1566. 

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

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

  1569. 

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

  1571.         break;

  1572. 

  1573.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR: {

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

  1575. 

  1576. #ifdef CARLA_OS_LINUX

  1577.         const ScopedEngineEnvironmentLocker _seel(this);

  1578. 

  1579.         if (value != 0)

  1580.         {

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

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

  1583.         }

  1584.         else

  1585.         {

  1586.             ::unsetenv("LD_PRELOAD");

  1587.         }

  1588. #endif

  1589.     }   break;

  1590. 

  1591.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  1594.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1596.     }   break;

  1597. 

  1598. #ifndef CARLA_OS_WIN

  1599.     case ENGINE_OPTION_WINE_EXECUTABLE:

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

  1601. 

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

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

  1604. 

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

  1606.         break;

  1607. 

  1608.     case ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  1611.         break;

  1612. 

  1613.     case ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  1615. 

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

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

  1618. 

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

  1620.         break;

  1621. 

  1622.     case ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  1625.         break;

  1626. 

  1627.     case ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  1630.         break;

  1631. 

  1632.     case ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  1635.         break;

  1636. #endif

  1637. 

  1638.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  1639.         break;

  1640.     }

  1641. }

  1642. 

  1643. #ifdef HAVE_LIBLO

  1644. // -----------------------------------------------------------------------

  1645. // OSC Stuff

  1646. 

  1647. # ifndef BUILD_BRIDGE

  1648. bool CarlaEngine::isOscControlRegistered() const noexcept

  1649. {

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

  1651. }

  1652. # endif

  1653. 

  1654. void CarlaEngine::idleOsc() const noexcept

  1655. {

  1656.     pData->osc.idle();

  1657. }

  1658. 

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

  1660. {

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

  1662. }

  1663. 

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

  1665. {

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

  1667. }

  1668. #endif

  1669. 

  1670. // -----------------------------------------------------------------------

  1671. // Helper functions

  1672. 

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

  1674. {

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

  1676. }

  1677. 

  1678. // -----------------------------------------------------------------------

  1679. // Internal stuff

  1680. 

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

  1682. {

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

  1684. 

  1685. #ifndef BUILD_BRIDGE

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

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

  1688.     {

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

  1690.     }

  1691. #endif

  1692. 

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

  1694. 

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

  1696.     {

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

  1698. 

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

  1700.             plugin->bufferSizeChanged(newBufferSize);

  1701.     }

  1702. 

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

  1704. }

  1705. 

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

  1707. {

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

  1709. 

  1710. #ifndef BUILD_BRIDGE

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

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

  1713.     {

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

  1715.     }

  1716. #endif

  1717. 

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

  1719. 

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

  1721.     {

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

  1723. 

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

  1725.             plugin->sampleRateChanged(newSampleRate);

  1726.     }

  1727. 

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

  1729. }

  1730. 

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

  1732. {

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

  1734. 

  1735. #ifndef BUILD_BRIDGE

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

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

  1738.     {

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

  1740.     }

  1741. #endif

  1742. 

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

  1744.     {

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

  1746. 

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

  1748.             plugin->offlineModeChanged(isOfflineNow);

  1749.     }

  1750. }

  1751. 

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

  1753. {

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

  1755. 

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

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

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

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

  1760. }

  1761. 

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

  1763. {

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

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

  1766.     {

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

  1768. 

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

  1770.         {

  1771. #ifndef BUILD_BRIDGE

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

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

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

  1775. #endif

  1776.             plugin->prepareForSave();

  1777.         }

  1778.     }

  1779. 

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

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

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

  1783. 

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

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

  1786. 

  1787.     MemoryOutputStream outSettings(1024);

  1788. 

  1789.     // save appropriate engine settings

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

  1791. 

  1792.     //processMode

  1793.     //transportMode

  1794. 

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

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

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

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

  1799. 

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

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

  1802. 

  1803.     if (isPlugin)

  1804.     {

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

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

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

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

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

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

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

  1812.     }

  1813. 

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

  1815.     outStream << outSettings;

  1816. 

  1817.     char strBuf[STR_MAX+1];

  1818. 

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

  1820.     {

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

  1822. 

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

  1824.         {

  1825.             MemoryOutputStream outPlugin(4096), streamPlugin;

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

  1827. 

  1828.             outPlugin << "\n";

  1829. 

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

  1831.             plugin->getRealName(strBuf);

  1832. 

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

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

  1835. 

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

  1837.             outPlugin << streamPlugin;

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

  1839.             outStream << outPlugin;

  1840.         }

  1841.     }

  1842. 

  1843. #ifndef BUILD_BRIDGE

  1844.     // tell bridges we're done saving

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

  1846.     {

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

  1848. 

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

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

  1851.     }

  1852. 

  1853.     // save internal connections

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

  1855.     {

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

  1857.         {

  1858.             MemoryOutputStream outPatchbay(2048);

  1859. 

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

  1861. 

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

  1863.             {

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

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

  1866. 

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

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

  1869. 

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

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

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

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

  1874.             }

  1875. 

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

  1877.             outStream << outPatchbay;

  1878.         }

  1879.     }

  1880. 

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

  1882.     bool saveExternalConnections;

  1883. 

  1884.     /**/ if (isPlugin)

  1885.         saveExternalConnections = false;

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

  1887.         saveExternalConnections = true;

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

  1889.         saveExternalConnections = false;

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

  1891.         saveExternalConnections = false;

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

  1893.         saveExternalConnections = false;

  1894.     else

  1895.         saveExternalConnections = true;

  1896. 

  1897.     if (saveExternalConnections)

  1898.     {

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

  1900.         {

  1901.             MemoryOutputStream outPatchbay(2048);

  1902. 

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

  1904. 

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

  1906.             {

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

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

  1909. 

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

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

  1912. 

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

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

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

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

  1917.             }

  1918. 

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

  1920.             outStream << outPatchbay;

  1921.         }

  1922.     }

  1923. #endif

  1924. 

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

  1926. }

  1927. 

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

  1929. {

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

  1931. 

  1932.     // try direct filename first

  1933.     String jbinary(binary);

  1934. 

  1935.     // adjust for current platform

  1936. #ifdef CARLA_OS_WIN

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

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

  1939. #else

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

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

  1942. #endif

  1943. 

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

  1945. 

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

  1947. #ifdef CARLA_OS_MAC

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

  1949.         searchFlags |= File::findDirectories;

  1950. #endif

  1951. 

  1952.     Array<File> results;

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

  1954.     {

  1955.         const File path(*it);

  1956. 

  1957.         results.clear();

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

  1959. 

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

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

  1962.     }

  1963. 

  1964.     // try changing extension

  1965. #if defined(CARLA_OS_MAC)

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

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

  1968. #elif defined(CARLA_OS_WIN)

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

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

  1971. #else

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

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

  1974. #endif

  1975.     else

  1976.         return String();

  1977. 

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

  1979.     {

  1980.         const File path(*it);

  1981. 

  1982.         results.clear();

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

  1984. 

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

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

  1987.     }

  1988. 

  1989.     return String();

  1990. }

  1991. 

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

  1993. {

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

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

  1996. 

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

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

  1999. 

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

  2001.     {

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

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

  2004.         return false;

  2005.     }

  2006. 

  2007. #ifndef BUILD_BRIDGE

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

  2009. #endif

  2010. 

  2011.     // completely load file

  2012.     xmlElement = xmlDoc.getDocumentElement(false);

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

  2014. 

  2015.     if (pData->aboutToClose)

  2016.         return true;

  2017. 

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

  2019. 

  2020.     // engine settings

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

  2022.     {

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

  2024. 

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

  2026.             continue;

  2027. 

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

  2029.         {

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

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

  2032. 

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

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

  2035. 

  2036.            int option = -1;

  2037.            int value  = 0;

  2038.            const char* valueStr = nullptr;

  2039. 

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

  2041.             {

  2042.                 option = ENGINE_OPTION_FORCE_STEREO;

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

  2044.             }

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

  2046.             {

  2047.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

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

  2049.             }

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

  2051.             {

  2052.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

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

  2054.             }

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

  2056.             {

  2057.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

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

  2059.             }

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

  2061.             {

  2062.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2063.                 value  = text.getIntValue();

  2064.             }

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

  2066.             {

  2067.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2068.                 value  = text.getIntValue();

  2069.             }

  2070.             else if (isPlugin)

  2071.             {

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

  2073.                 {

  2074.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2075.                     value    = PLUGIN_LADSPA;

  2076.                     valueStr = text.toRawUTF8();

  2077.                 }

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

  2079.                 {

  2080.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2081.                     value    = PLUGIN_DSSI;

  2082.                     valueStr = text.toRawUTF8();

  2083.                 }

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

  2085.                 {

  2086.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2087.                     value    = PLUGIN_LV2;

  2088.                     valueStr = text.toRawUTF8();

  2089.                 }

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

  2091.                 {

  2092.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2093.                     value    = PLUGIN_VST2;

  2094.                     valueStr = text.toRawUTF8();

  2095.                 }

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

  2097.                 {

  2098.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2099.                     value    = PLUGIN_GIG;

  2100.                     valueStr = text.toRawUTF8();

  2101.                 }

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

  2103.                 {

  2104.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2105.                     value    = PLUGIN_SF2;

  2106.                     valueStr = text.toRawUTF8();

  2107.                 }

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

  2109.                 {

  2110.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2111.                     value    = PLUGIN_SFZ;

  2112.                     valueStr = text.toRawUTF8();

  2113.                 }

  2114.             }

  2115. 

  2116.             CARLA_SAFE_ASSERT_CONTINUE(option != -1);

  2117. 

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

  2119.         }

  2120. 

  2121.         break;

  2122.     }

  2123. 

  2124.     if (pData->aboutToClose)

  2125.         return true;

  2126. 

  2127.     // handle plugins first

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

  2129.     {

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

  2131. 

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

  2133.         {

  2134.             CarlaStateSave stateSave;

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

  2136. 

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

  2138. 

  2139.             if (pData->aboutToClose)

  2140.                 return true;

  2141. 

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

  2143. 

  2144.             const void* extraStuff    = nullptr;

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

  2146. 

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

  2148. 

  2149.             switch (ptype)

  2150.             {

  2151.             case PLUGIN_GIG:

  2152.             case PLUGIN_SF2:

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

  2154.                     extraStuff = kTrue;

  2155.                 // fall through

  2156.             case PLUGIN_LADSPA:

  2157.             case PLUGIN_DSSI:

  2158.             case PLUGIN_VST2:

  2159.             case PLUGIN_SFZ:

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

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

  2162.                 {

  2163.                     const char* searchPath;

  2164. 

  2165.                     switch (ptype)

  2166.                     {

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

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

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

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

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

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

  2173.                     default:            searchPath = nullptr;                   break;

  2174.                     }

  2175. 

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

  2177.                     {

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

  2179.                                      stateSave.binary);

  2180. 

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

  2182. 

  2183.                         if (result.isEmpty())

  2184.                         {

  2185.                             switch (ptype)

  2186.                             {

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

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

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

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

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

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

  2193.                             default:            searchPath = nullptr;                    break;

  2194.                             }

  2195. 

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

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

  2198.                         }

  2199. 

  2200.                         if (result.isNotEmpty())

  2201.                         {

  2202.                             delete[] stateSave.binary;

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

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

  2205.                         }

  2206.                         else

  2207.                         {

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

  2209.                         }

  2210.                     }

  2211.                 }

  2212.                 break;

  2213.             default:

  2214.                 break;

  2215.             }

  2216. 

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

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

  2219.             {

  2220. #ifndef BUILD_BRIDGE

  2221.                 const uint pluginId = pData->curPluginCount;

  2222. #else

  2223.                 const uint pluginId = 0;

  2224. #endif

  2225. 

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

  2227.                 {

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

  2229. 

  2230.                     if (pData->aboutToClose)

  2231.                         return true;

  2232. 

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

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

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

  2236. 

  2237.                     plugin->loadStateSave(stateSave);

  2238. 

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

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

  2241.                      *        as we want to load state first.

  2242.                      */

  2243. #ifdef BUILD_BRIDGE

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

  2245. #else

  2246.                     ++pData->curPluginCount;

  2247. #endif

  2248. 

  2249.                     plugin->setEnabled(true);

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

  2251. 

  2252. #ifndef BUILD_BRIDGE

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

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

  2255. #endif

  2256.                 }

  2257.                 else

  2258.                 {

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

  2260.                 }

  2261.             }

  2262.             else

  2263.             {

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

  2265.             }

  2266.         }

  2267. 

  2268.         if (isPreset)

  2269.             return true;

  2270.     }

  2271. 

  2272. #ifndef BUILD_BRIDGE

  2273.     // tell bridges we're done loading

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

  2275.     {

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

  2277. 

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

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

  2280.     }

  2281. 

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

  2283. 

  2284.     if (pData->aboutToClose)

  2285.         return true;

  2286. 

  2287.     // handle connections (internal)

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

  2289.     {

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

  2291. 

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

  2293.         {

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

  2295. 

  2296.             // only load internal patchbay connections

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

  2298.                 continue;

  2299. 

  2300.             CarlaString sourcePort, targetPort;

  2301. 

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

  2303.             {

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

  2305. 

  2306.                 sourcePort.clear();

  2307.                 targetPort.clear();

  2308. 

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

  2310.                     continue;

  2311. 

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

  2313.                 {

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

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

  2316. 

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

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

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

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

  2321.                 }

  2322. 

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

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

  2325.             }

  2326.             break;

  2327.         }

  2328. 

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

  2330. 

  2331.         if (pData->aboutToClose)

  2332.             return true;

  2333.     }

  2334. 

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

  2336.     bool loadExternalConnections;

  2337. 

  2338.     /**/ if (isPlugin)

  2339.         loadExternalConnections = false;

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

  2341.         loadExternalConnections = true;

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

  2343.         loadExternalConnections = false;

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

  2345.         loadExternalConnections = false;

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

  2347.         loadExternalConnections = false;

  2348.     else

  2349.         loadExternalConnections = true;

  2350. 

  2351.     // handle connections

  2352.     if (loadExternalConnections)

  2353.     {

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

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

  2356. 

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

  2358.         {

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

  2360. 

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

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

  2363.             {

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

  2365.                     continue;

  2366.             }

  2367.             // or load external patchbay connections

  2368.             else if (! tagName.equalsIgnoreCase("externalpatchbay"))

  2369.             {

  2370.                 continue;

  2371.             }

  2372. 

  2373.             CarlaString sourcePort, targetPort;

  2374. 

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

  2376.             {

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

  2378. 

  2379.                 sourcePort.clear();

  2380.                 targetPort.clear();

  2381. 

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

  2383.                     continue;

  2384. 

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

  2386.                 {

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

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

  2389. 

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

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

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

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

  2394.                 }

  2395. 

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

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

  2398.             }

  2399.             break;

  2400.         }

  2401.     }

  2402. 

  2403. #endif

  2404. 

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

  2406.     return true;

  2407. }

  2408. 

  2409. // -----------------------------------------------------------------------

  2410. 

  2411. CARLA_BACKEND_END_NAMESPACE