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

1580 lines
50KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. /* TODO:

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

  20.  * - implement processPatchbay()

  21.  * - implement oscSend_control_switch_plugins()

  22.  * - proper find&load plugins

  23.  * - something about the peaks?

  24.  * - patchbayDisconnect should return false sometimes

  25.  */

  26. 

  27. #include "CarlaEngineInternal.hpp"

  28. #include "CarlaPlugin.hpp"

  29. 

  30. #include "CarlaBackendUtils.hpp"

  31. #include "CarlaEngineUtils.hpp"

  32. #include "CarlaMathUtils.hpp"

  33. #include "CarlaStateUtils.hpp"

  34. #include "CarlaMIDI.h"

  35. 

  36. #include "jackbridge/JackBridge.hpp"

  37. #include "juce_core.h"

  38. 

  39. using juce::File;

  40. using juce::MemoryOutputStream;

  41. using juce::ScopedPointer;

  42. using juce::String;

  43. using juce::XmlDocument;

  44. using juce::XmlElement;

  45. 

  46. CARLA_BACKEND_START_NAMESPACE

  47. 

  48. // -----------------------------------------------------------------------

  49. // Carla Engine

  50. 

  51. CarlaEngine::CarlaEngine()

  52.     : pData(new ProtectedData(this))

  53. {

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

  55. }

  56. 

  57. CarlaEngine::~CarlaEngine()

  58. {

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

  60. 

  61.     delete pData;

  62. }

  63. 

  64. // -----------------------------------------------------------------------

  65. // Static calls

  66. 

  67. uint CarlaEngine::getDriverCount()

  68. {

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

  70. 

  71.     uint count = 0;

  72. 

  73.     if (jackbridge_is_ok())

  74.         count += 1;

  75. 

  76. #ifndef BUILD_BRIDGE

  77.     count += getRtAudioApiCount();

  78.     count += getJuceApiCount();

  79. #endif

  80. 

  81.     return count;

  82. }

  83. 

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

  85. {

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

  87. 

  88.     uint index(index2);

  89. 

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

  91.         return "JACK";

  92. 

  93. #ifndef BUILD_BRIDGE

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

  95.     {

  96.         if (index < count)

  97.             return getRtAudioApiName(index);

  98.         index -= count;

  99.     }

  100. 

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

  102.     {

  103.         if (index < count)

  104.             return getJuceApiName(index);

  105.         //index -= count;

  106.     }

  107. #endif

  108. 

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

  110.     return nullptr;

  111. }

  112. 

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

  114. {

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

  116. 

  117.     uint index(index2);

  118. 

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

  120.     {

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

  122.         return ret;

  123.     }

  124. 

  125. #ifndef BUILD_BRIDGE

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

  127.     {

  128.         if (index < count)

  129.             return getRtAudioApiDeviceNames(index);

  130.         index -= count;

  131.     }

  132. 

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

  134.     {

  135.         if (index < count)

  136.             return getJuceApiDeviceNames(index);

  137.         //index -= count;

  138.     }

  139. #endif

  140. 

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

  142.     return nullptr;

  143. }

  144. 

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

  146. {

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

  148. 

  149.     uint index(index2);

  150. 

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

  152.     {

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

  154.         static EngineDriverDeviceInfo devInfo;

  155.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  156.         devInfo.bufferSizes = bufSizes;

  157.         devInfo.sampleRates = nullptr;

  158.         return &devInfo;

  159.     }

  160. 

  161. #ifndef BUILD_BRIDGE

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

  163.     {

  164.         if (index < count)

  165.             return getRtAudioDeviceInfo(index, deviceName);

  166.         index -= count;

  167.     }

  168. 

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

  170.     {

  171.         if (index < count)

  172.             return getJuceDeviceInfo(index, deviceName);

  173.         //index -= count;

  174.     }

  175. #endif

  176. 

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

  178.     return nullptr;

  179. }

  180. 

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

  182. {

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

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

  185. 

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

  187.         return newJack();

  188. 

  189. #ifndef BUILD_BRIDGE

  190.     // -------------------------------------------------------------------

  191.     // common

  192. 

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

  194.         return newRtAudio(AUDIO_API_JACK);

  195. 

  196.     // -------------------------------------------------------------------

  197.     // linux

  198. 

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

  200.         //return newJuce(AUDIO_API_ALSA);

  201.         return newRtAudio(AUDIO_API_ALSA);

  202. 

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

  204.         return newRtAudio(AUDIO_API_OSS);

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

  206.         return newRtAudio(AUDIO_API_PULSE);

  207. 

  208.     // -------------------------------------------------------------------

  209.     // macos

  210. 

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

  212.         return newJuce(AUDIO_API_CORE);

  213. 

  214.     // -------------------------------------------------------------------

  215.     // windows

  216. 

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

  218.         return newJuce(AUDIO_API_ASIO);

  219. 

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

  221.         return newJuce(AUDIO_API_DS);

  222. #endif

  223. 

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

  225.     return nullptr;

  226. }

  227. 

  228. // -----------------------------------------------------------------------

  229. // Constant values

  230. 

  231. uint CarlaEngine::getMaxClientNameSize() const noexcept

  232. {

  233.     return STR_MAX/2;

  234. }

  235. 

  236. uint CarlaEngine::getMaxPortNameSize() const noexcept

  237. {

  238.     return STR_MAX;

  239. }

  240. 

  241. uint CarlaEngine::getCurrentPluginCount() const noexcept

  242. {

  243.     return pData->curPluginCount;

  244. }

  245. 

  246. uint CarlaEngine::getMaxPluginNumber() const noexcept

  247. {

  248.     return pData->maxPluginNumber;

  249. }

  250. 

  251. // -----------------------------------------------------------------------

  252. // Virtual, per-engine type calls

  253. 

  254. bool CarlaEngine::init(const char* const clientName)

  255. {

  256.     carla_debug("CarlaEngine::init(\"%s\")", clientName);

  257. 

  258.     if (! pData->init(clientName))

  259.         return false;

  260. 

  261.     callback(ENGINE_CALLBACK_ENGINE_STARTED, 0, pData->options.processMode, pData->options.transportMode, 0.0f, getCurrentDriverName());

  262.     return true;

  263. }

  264. 

  265. bool CarlaEngine::close()

  266. {

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

  268. 

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

  270.     {

  271.         pData->aboutToClose = true;

  272.         removeAllPlugins();

  273.     }

  274. 

  275. #ifndef BUILD_BRIDGE

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

  277.         oscSend_control_exit();

  278. #endif

  279. 

  280.     pData->close();

  281. 

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

  283.     return true;

  284. }

  285. 

  286. void CarlaEngine::idle() noexcept

  287. {

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

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

  290. 

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

  292.     {

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

  294. 

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

  296.         {

  297.             try {

  298.                 plugin->idle();

  299.             } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin idle");

  300.         }

  301.     }

  302. 

  303.     pData->osc.idle();

  304. }

  305. 

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

  307. {

  308.     return new CarlaEngineClient(*this);

  309. }

  310. 

  311. // -----------------------------------------------------------------------

  312. // Plugin management

  313. 

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

  315. {

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

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

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

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

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

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

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

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

  324. 

  325.     uint id;

  326. 

  327. #ifndef BUILD_BRIDGE

  328.     CarlaPlugin* oldPlugin = nullptr;

  329. 

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

  331.     {

  332.         id = pData->nextPluginId;

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

  334. 

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

  336. 

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

  338.     }

  339.     else

  340. #endif

  341.     {

  342.         id = pData->curPluginCount;

  343. 

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

  345.         {

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

  347.             return false;

  348.         }

  349. 

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

  351.     }

  352. 

  353.     CarlaPlugin::Initializer initializer = {

  354.         this,

  355.         id,

  356.         filename,

  357.         name,

  358.         label,

  359.         uniqueId

  360.     };

  361. 

  362.     CarlaPlugin* plugin = nullptr;

  363. 

  364. #ifndef BUILD_BRIDGE

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

  366. 

  367.     if (bridgeBinary.isNotEmpty())

  368.     {

  369. # ifndef CARLA_OS_WIN

  370.         if (btype == BINARY_NATIVE)

  371.         {

  372.             bridgeBinary += OS_SEP_STR "carla-bridge-native";

  373.         }

  374.         else

  375. # endif

  376.         {

  377.             switch (btype)

  378.             {

  379.             case BINARY_POSIX32:

  380.                 bridgeBinary += OS_SEP_STR "carla-bridge-posix32";

  381.                 break;

  382.             case BINARY_POSIX64:

  383.                 bridgeBinary += OS_SEP_STR "carla-bridge-posix64";

  384.                 break;

  385.             case BINARY_WIN32:

  386.                 bridgeBinary += OS_SEP_STR "carla-bridge-win32.exe";

  387.                 break;

  388.             case BINARY_WIN64:

  389.                 bridgeBinary += OS_SEP_STR "carla-bridge-win64.exe";

  390.                 break;

  391.             default:

  392.                 bridgeBinary.clear();

  393.                 break;

  394.             }

  395.         }

  396. 

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

  398.             bridgeBinary.clear();

  399.     }

  400. 

  401.     if (ptype != PLUGIN_INTERNAL && (btype != BINARY_NATIVE || (pData->options.preferPluginBridges && bridgeBinary.isNotEmpty())))

  402.     {

  403.         if (bridgeBinary.isNotEmpty())

  404.         {

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

  406.         }

  407. # ifdef CARLA_OS_LINUX

  408.         else if (btype == BINARY_WIN32)

  409.         {

  410.             // fallback to dssi-vst

  411.             File file(filename);

  412. 

  413.             CarlaString label2(file.getFullPathName().toRawUTF8());

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

  415. 

  416.             CarlaPlugin::Initializer init2 = {

  417.                 this,

  418.                 id,

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

  420.                 name,

  421.                 label2,

  422.                 uniqueId

  423.             };

  424. 

  425.             char* const oldVstPath(getenv("VST_PATH"));

  426.             carla_setenv("VST_PATH", file.getParentDirectory().getFullPathName().toRawUTF8());

  427. 

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

  429. 

  430.             if (oldVstPath != nullptr)

  431.                 carla_setenv("VST_PATH", oldVstPath);

  432.         }

  433. # endif

  434.         else

  435.         {

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

  437.             return false;

  438.         }

  439.     }

  440.     else

  441. #endif // ! BUILD_BRIDGE

  442.     {

  443.         bool use16Outs;

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

  445. 

  446.         switch (ptype)

  447.         {

  448.         case PLUGIN_NONE:

  449.             break;

  450. 

  451.         case PLUGIN_INTERNAL:

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

  453.             {

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

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

  456.             }

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

  458.             {

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

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

  461.             }

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

  463.             {

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

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

  466.             }

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

  468.             {

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

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

  471.             }*/

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

  473.             break;

  474. 

  475.         case PLUGIN_LADSPA:

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

  477.             break;

  478. 

  479.         case PLUGIN_DSSI:

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

  481.             break;

  482. 

  483.         case PLUGIN_LV2:

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

  485.             break;

  486. 

  487.         case PLUGIN_VST:

  488.             plugin = CarlaPlugin::newVST(initializer);

  489.             break;

  490. 

  491.         case PLUGIN_VST3:

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

  493.             break;

  494. 

  495.         case PLUGIN_AU:

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

  497.             break;

  498. 

  499.         case PLUGIN_GIG:

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

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

  502.             break;

  503. 

  504.         case PLUGIN_SF2:

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

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

  507.             break;

  508. 

  509.         case PLUGIN_SFZ:

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

  511.             break;

  512.         }

  513.     }

  514. 

  515.     if (plugin == nullptr)

  516.         return false;

  517. 

  518.     plugin->registerToOscClient();

  519. 

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

  521.     pluginData.plugin      = plugin;

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

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

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

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

  526. 

  527. #ifndef BUILD_BRIDGE

  528.     if (oldPlugin != nullptr)

  529.     {

  530.         // the engine thread might be reading from the old plugin

  531.         pData->thread.stopThread(500);

  532.         pData->thread.startThread();

  533. 

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

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

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

  537. 

  538.         delete oldPlugin;

  539. 

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

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

  542. 

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

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

  545. 

  546.         if (wasActive)

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

  548. 

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

  550.     }

  551.     else

  552. #endif

  553.     {

  554.         ++pData->curPluginCount;

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

  556.     }

  557. 

  558.     return true;

  559. }

  560. 

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

  562. {

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

  564. }

  565. 

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

  567. {

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

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

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

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

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

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

  574. 

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

  576. 

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

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

  579. 

  580.     pData->thread.stopThread(500);

  581. 

  582. #ifndef BUILD_BRIDGE

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

  584.     const ScopedActionLock sal(pData, kEnginePostActionRemovePlugin, id, 0, lockWait);

  585. 

  586.     if (isOscControlRegistered())

  587.         oscSend_control_remove_plugin(id);

  588. #else

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

  590. #endif

  591. 

  592.     delete plugin;

  593. 

  594.     if (isRunning() && ! pData->aboutToClose)

  595.         pData->thread.startThread();

  596. 

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

  598.     return true;

  599. }

  600. 

  601. bool CarlaEngine::removeAllPlugins()

  602. {

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

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

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

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

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

  608. 

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

  610.         return true;

  611. 

  612.     pData->thread.stopThread(500);

  613. 

  614.     const bool lockWait(isRunning());

  615.     const ScopedActionLock sal(pData, kEnginePostActionZeroCount, 0, 0, lockWait);

  616. 

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

  618. 

  619.     for (uint i=0; i < pData->maxPluginNumber; ++i)

  620.     {

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

  622. 

  623.         if (pluginData.plugin != nullptr)

  624.         {

  625.             delete pluginData.plugin;

  626.             pluginData.plugin = nullptr;

  627.         }

  628. 

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

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

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

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

  633. 

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

  635.     }

  636. 

  637.     if (isRunning() && ! pData->aboutToClose)

  638.         pData->thread.startThread();

  639. 

  640.     return true;

  641. }

  642. 

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

  644. {

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

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

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

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

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

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

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

  652. 

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

  654. 

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

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

  657. 

  658.     if (const char* const name = getUniquePluginName(newName))

  659.     {

  660.         plugin->setName(name);

  661.         return name;

  662.     }

  663. 

  664.     setLastError("Unable to get new unique plugin name");

  665.     return nullptr;

  666. }

  667. 

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

  669. {

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

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

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

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

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

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

  676. 

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

  678. 

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

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

  681. 

  682.     char label[STR_MAX+1];

  683.     carla_zeroChar(label, STR_MAX+1);

  684.     plugin->getLabel(label);

  685. 

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

  687. 

  688.     if (! addPlugin(plugin->getBinaryType(), plugin->getType(), plugin->getFilename(), plugin->getName(), label, plugin->getUniqueId(), plugin->getExtraStuff()))

  689.         return false;

  690. 

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

  692. 

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

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

  695. 

  696.     return true;

  697. }

  698. 

  699. bool CarlaEngine::replacePlugin(const uint id)

  700. {

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

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

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

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

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

  706. 

  707.     // might use this to reset

  708.     if (id == pData->curPluginCount || id == pData->maxPluginNumber)

  709.     {

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

  711.         return true;

  712.     }

  713. 

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

  715. 

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

  717. 

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

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

  720. 

  721.     pData->nextPluginId = id;

  722. 

  723.     return true;

  724. }

  725. 

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

  727. {

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

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

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

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

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

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

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

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

  736. 

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

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

  739. 

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

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

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

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

  744. 

  745.     pData->thread.stopThread(500);

  746. 

  747. #ifndef BUILD_BRIDGE

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

  749.     const ScopedActionLock sal(pData, kEnginePostActionSwitchPlugins, idA, idB, lockWait);

  750. 

  751.     // TODO

  752.     //if (isOscControlRegistered())

  753.     //    oscSend_control_switch_plugins(idA, idB);

  754. #else

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

  756. #endif

  757. 

  758.     if (isRunning() && ! pData->aboutToClose)

  759.         pData->thread.startThread();

  760. 

  761.     return true;

  762. }

  763. 

  764. CarlaPlugin* CarlaEngine::getPlugin(const uint id) const

  765. {

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

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

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

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

  770. 

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

  772. }

  773. 

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

  775. {

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

  777. }

  778. 

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

  780. {

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

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

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

  784. 

  785.     CarlaString sname;

  786.     sname = name;

  787. 

  788.     if (sname.isEmpty())

  789.     {

  790.         sname = "(No name)";

  791.         return sname.dup();

  792.     }

  793. 

  794.     const size_t maxNameSize(carla_min<uint>(getMaxClientNameSize(), 0xff, 6) - 6); // 6 = strlen(" (10)") + 1

  795. 

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

  797.         return sname.dup();

  798. 

  799.     sname.truncate(maxNameSize);

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

  801. 

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

  803.     {

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

  805. 

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

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

  808.         {

  809.             if (sname != pluginName)

  810.                 continue;

  811.         }

  812. 

  813.         // Check if string has already been modified

  814.         {

  815.             const size_t len(sname.length());

  816. 

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

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

  819.             {

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

  821. 

  822.                 if (number == 9)

  823.                 {

  824.                     // next number is 10, 2 digits

  825.                     sname.truncate(len-4);

  826.                     sname += " (10)";

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

  828.                 }

  829.                 else

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

  831. 

  832.                 continue;

  833.             }

  834. 

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

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

  837.             {

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

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

  840. 

  841.                 if (n2 == '9')

  842.                 {

  843.                     n2 = '0';

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

  845.                 }

  846.                 else

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

  848. 

  849.                 sname[len-2] = n2;

  850.                 sname[len-3] = n3;

  851. 

  852.                 continue;

  853.             }

  854.         }

  855. 

  856.         // Modify string if not

  857.         sname += " (2)";

  858.     }

  859. 

  860.     return sname.dup();

  861. }

  862. 

  863. // -----------------------------------------------------------------------

  864. // Project management

  865. 

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

  867. {

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

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

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

  871. 

  872.     File file(filename);

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

  874. 

  875.     CarlaString baseName(file.getFileName().toRawUTF8());

  876.     CarlaString extension(file.getFileExtension().toRawUTF8());

  877.     extension.toLower();

  878. 

  879.     // -------------------------------------------------------------------

  880. 

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

  882.         return loadProject(filename);

  883. 

  884.     // -------------------------------------------------------------------

  885. 

  886.     if (extension == "gig")

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

  888. 

  889.     if (extension == "sf2")

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

  891. 

  892.     if (extension == "sfz")

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

  894. 

  895.     // -------------------------------------------------------------------

  896. 

  897.     if (extension == "aiff" || extension == "flac" || extension == "oga" || extension == "ogg" || extension == "w64" || extension == "wav")

  898.     {

  899. #ifdef WANT_AUDIOFILE

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

  901.         {

  902.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

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

  904.             return true;

  905.         }

  906.         return false;

  907. #else

  908.         setLastError("This Carla build does not have Audio file support");

  909.         return false;

  910. #endif

  911.     }

  912. 

  913.     if (extension == "3g2" || extension == "3gp" || extension == "aac" || extension == "ac3" || extension == "amr" || extension == "ape" ||

  914.             extension == "mp2" || extension == "mp3" || extension == "mpc" || extension == "wma")

  915.     {

  916. #ifdef WANT_AUDIOFILE

  917. # ifdef HAVE_FFMPEG

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

  919.         {

  920.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

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

  922.             return true;

  923.         }

  924.         return false;

  925. # else

  926.         setLastError("This Carla build has Audio file support, but not libav/ffmpeg");

  927.         return false;

  928. # endif

  929. #else

  930.         setLastError("This Carla build does not have Audio file support");

  931.         return false;

  932. #endif

  933.     }

  934. 

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

  936. 

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

  938.     {

  939. #ifdef WANT_MIDIFILE

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

  941.         {

  942.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

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

  944.             return true;

  945.         }

  946.         return false;

  947. #else

  948.         setLastError("This Carla build does not have MIDI file support");

  949.         return false;

  950. #endif

  951.     }

  952. 

  953.     // -------------------------------------------------------------------

  954.     // ZynAddSubFX

  955. 

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

  957.     {

  958. #ifdef WANT_ZYNADDSUBFX

  959.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "zynaddsubfx", 0, nullptr))

  960.         {

  961.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

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

  963.             return true;

  964.         }

  965.         return false;

  966. #else

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

  968.         return false;

  969. #endif

  970.     }

  971. 

  972.     // -------------------------------------------------------------------

  973. 

  974.     setLastError("Unknown file extension");

  975.     return false;

  976. }

  977. 

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

  979. {

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

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

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

  983. 

  984.     File file(filename);

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

  986. 

  987.     XmlDocument xml(file);

  988.     ScopedPointer<XmlElement> xmlElement(xml.getDocumentElement(true));

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

  990. 

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

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

  993. 

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

  995.     {

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

  997.         return false;

  998.     }

  999. 

  1000.     // completely load file

  1001.     xmlElement = xml.getDocumentElement(false);

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

  1003. 

  1004.     // handle plugins first

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

  1006.     {

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

  1008. 

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

  1010.         {

  1011.             StateSave stateSave;

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

  1013. 

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

  1015. 

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

  1017. 

  1018.             const void* extraStuff = nullptr;

  1019. 

  1020.             // check if using GIG, SF2 or SFZ 16outs

  1021.             static const char kUse16OutsSuffix[] = " (16 outs)";

  1022. 

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

  1024. 

  1025.             if (CarlaString(stateSave.label).endsWith(kUse16OutsSuffix))

  1026.             {

  1027.                 if (ptype == PLUGIN_GIG || ptype == PLUGIN_SF2)

  1028.                     extraStuff = "true";

  1029.             }

  1030. 

  1031.             // TODO - proper find&load plugins

  1032. 

  1033.             if (addPlugin(ptype, stateSave.binary, stateSave.name, stateSave.label, stateSave.uniqueId, extraStuff))

  1034.             {

  1035.                 if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  1036.                     plugin->loadStateSave(stateSave);

  1037.             }

  1038.             else

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

  1040.         }

  1041. 

  1042.         if (isPreset)

  1043.             return true;

  1044.     }

  1045. 

  1046. #ifndef BUILD_BRIDGE

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

  1048. 

  1049.     // if we're running inside some session-manager, let them handle the connections

  1050.     if (pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY)

  1051.     {

  1052.         if (std::getenv("CARLA_DONT_MANAGE_CONNECTIONS") != nullptr || std::getenv("LADISH_APP_NAME") != nullptr || std::getenv("NSM_URL") != nullptr)

  1053.             return true;

  1054.     }

  1055. 

  1056.     // now handle connections

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

  1058.     {

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

  1060. 

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

  1062.         {

  1063.             CarlaString sourcePort, targetPort;

  1064. 

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

  1066.             {

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

  1068. 

  1069.                 sourcePort.clear();

  1070.                 targetPort.clear();

  1071. 

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

  1073.                     continue;

  1074. 

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

  1076.                 {

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

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

  1079. 

  1080.                     if (tag.equalsIgnoreCase("source"))

  1081.                         sourcePort = text.toRawUTF8();

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

  1083.                         targetPort = text.toRawUTF8();

  1084.                 }

  1085. 

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

  1087.                     restorePatchbayConnection(sourcePort, targetPort);

  1088.             }

  1089.             break;

  1090.         }

  1091.     }

  1092. #endif

  1093. 

  1094.     return true;

  1095. }

  1096. 

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

  1098. {

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

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

  1101. 

  1102.     MemoryOutputStream out;

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

  1104.     out << "<!DOCTYPE CARLA-PROJECT>\n";

  1105.     out << "<CARLA-PROJECT VERSION='2.0'>\n";

  1106. 

  1107.     bool firstPlugin = true;

  1108.     char strBuf[STR_MAX+1];

  1109. 

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

  1111.     {

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

  1113. 

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

  1115.         {

  1116.             if (! firstPlugin)

  1117.                 out << "\n";

  1118. 

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

  1120. 

  1121.             plugin->getRealName(strBuf);

  1122. 

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

  1124.             //    out << QString(" <!-- %1 -->\n").arg(xmlSafeString(strBuf, true));

  1125. 

  1126.             out << " <Plugin>\n";

  1127.             out << plugin->getStateSave().toString();

  1128.             out << " </Plugin>\n";

  1129. 

  1130.             firstPlugin = false;

  1131.         }

  1132.     }

  1133. 

  1134. #ifndef BUILD_BRIDGE

  1135.     // if we're running inside some session-manager, let them handle the connections

  1136.     if (pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY)

  1137.     {

  1138.         if (std::getenv("CARLA_DONT_MANAGE_CONNECTIONS") != nullptr || std::getenv("LADISH_APP_NAME") != nullptr || std::getenv("NSM_URL") != nullptr)

  1139.             return true;

  1140.     }

  1141. 

  1142.     if (const char* const* patchbayConns = getPatchbayConnections())

  1143.     {

  1144.         if (! firstPlugin)

  1145.             out << "\n";

  1146. 

  1147.         out << " <Patchbay>\n";

  1148. 

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

  1150.         {

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

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

  1153. 

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

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

  1156. 

  1157.             out << "  <Connection>\n";

  1158.             out << "   <Source>" << connSource << "</Source>\n";

  1159.             out << "   <Target>" << connTarget << "</Target>\n";

  1160.             out << "  </Connection>\n";

  1161. 

  1162.             delete[] connSource;

  1163.             delete[] connTarget;

  1164.         }

  1165. 

  1166.         out << " </Patchbay>\n";

  1167.     }

  1168. #endif

  1169. 

  1170.     out << "</CARLA-PROJECT>\n";

  1171. 

  1172.     File file(filename);

  1173. 

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

  1175.         return true;

  1176. 

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

  1178.     return false;

  1179. }

  1180. 

  1181. // -----------------------------------------------------------------------

  1182. // Information (base)

  1183. 

  1184. uint CarlaEngine::getHints() const noexcept

  1185. {

  1186.     return pData->hints;

  1187. }

  1188. 

  1189. uint32_t CarlaEngine::getBufferSize() const noexcept

  1190. {

  1191.     return pData->bufferSize;

  1192. }

  1193. 

  1194. double CarlaEngine::getSampleRate() const noexcept

  1195. {

  1196.     return pData->sampleRate;

  1197. }

  1198. 

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

  1200. {

  1201.     return pData->name;

  1202. }

  1203. 

  1204. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1205. {

  1206.     return pData->options.processMode;

  1207. }

  1208. 

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

  1210. {

  1211.     return pData->options;

  1212. }

  1213. 

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

  1215. {

  1216.     return pData->timeInfo;

  1217. }

  1218. 

  1219. // -----------------------------------------------------------------------

  1220. // Information (peaks)

  1221. 

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

  1223. {

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

  1225. 

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

  1227. }

  1228. 

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

  1230. {

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

  1232. 

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

  1234. }

  1235. 

  1236. // -----------------------------------------------------------------------

  1237. // Callback

  1238. 

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

  1240. {

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

  1242. 

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

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

  1245. 

  1246.     if (action == ENGINE_CALLBACK_IDLE)

  1247.         pData->isIdling = true;

  1248. 

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

  1250.     {

  1251.         try {

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

  1253.         } catch(...) {}

  1254.     }

  1255. 

  1256.     if (action == ENGINE_CALLBACK_IDLE)

  1257.         pData->isIdling = false;

  1258. }

  1259. 

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

  1261. {

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

  1263. 

  1264.     pData->callback    = func;

  1265.     pData->callbackPtr = ptr;

  1266. }

  1267. 

  1268. // -----------------------------------------------------------------------

  1269. // File Callback

  1270. 

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

  1272. {

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

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

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

  1276. 

  1277.     const char* ret = nullptr;

  1278. 

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

  1280.     {

  1281.         try {

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

  1283.         } catch(...) {}

  1284.     }

  1285. 

  1286.     return ret;

  1287. }

  1288. 

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

  1290. {

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

  1292. 

  1293.     pData->fileCallback    = func;

  1294.     pData->fileCallbackPtr = ptr;

  1295. }

  1296. 

  1297. // -----------------------------------------------------------------------

  1298. // Transport

  1299. 

  1300. void CarlaEngine::transportPlay() noexcept

  1301. {

  1302.     pData->time.playing = true;

  1303. }

  1304. 

  1305. void CarlaEngine::transportPause() noexcept

  1306. {

  1307.     pData->time.playing = false;

  1308. }

  1309. 

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

  1311. {

  1312.     pData->time.frame = frame;

  1313. }

  1314. 

  1315. // -----------------------------------------------------------------------

  1316. // Error handling

  1317. 

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

  1319. {

  1320.     return pData->lastError;

  1321. }

  1322. 

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

  1324. {

  1325.     pData->lastError = error;

  1326. }

  1327. 

  1328. void CarlaEngine::setAboutToClose() noexcept

  1329. {

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

  1331. 

  1332.     pData->aboutToClose = true;

  1333. }

  1334. 

  1335. // -----------------------------------------------------------------------

  1336. // Global options

  1337. 

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

  1339. {

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

  1341. 

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

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

  1344. 

  1345.     switch (option)

  1346.     {

  1347.     case ENGINE_OPTION_DEBUG:

  1348.     case ENGINE_OPTION_NSM_INIT:

  1349.         break;

  1350. 

  1351.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1354.         break;

  1355. 

  1356.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1359.         break;

  1360. 

  1361.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1364.         break;

  1365. 

  1366.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1369.         break;

  1370. 

  1371.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1374.         break;

  1375. 

  1376.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1379.         break;

  1380. 

  1381.     case ENGINE_OPTION_MAX_PARAMETERS:

  1382.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1384.         break;

  1385. 

  1386.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1387.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1389.         break;

  1390. 

  1391.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1394.         break;

  1395. 

  1396.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1397.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1399.         break;

  1400. 

  1401.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1402.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1404.         break;

  1405. 

  1406.     case ENGINE_OPTION_AUDIO_DEVICE:

  1407.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1408. 

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

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

  1411. 

  1412.         pData->options.audioDevice = carla_strdup(valueStr);

  1413.         break;

  1414. 

  1415.     case ENGINE_OPTION_PATH_BINARIES:

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

  1417. 

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

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

  1420. 

  1421.         pData->options.binaryDir = carla_strdup(valueStr);

  1422.         break;

  1423. 

  1424.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1426. 

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

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

  1429. 

  1430.         pData->options.resourceDir = carla_strdup(valueStr);

  1431.         break;

  1432. 

  1433.     case ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1436.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1438.         break;

  1439.     }

  1440. }

  1441. 

  1442. // -----------------------------------------------------------------------

  1443. // OSC Stuff

  1444. 

  1445. #ifdef BUILD_BRIDGE

  1446. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1447. {

  1448.     return (pData->oscData != nullptr);

  1449. }

  1450. #else

  1451. bool CarlaEngine::isOscControlRegistered() const noexcept

  1452. {

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

  1454. }

  1455. #endif

  1456. 

  1457. void CarlaEngine::idleOsc() const noexcept

  1458. {

  1459.     pData->osc.idle();

  1460. }

  1461. 

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

  1463. {

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

  1465. }

  1466. 

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

  1468. {

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

  1470. }

  1471. 

  1472. #ifdef BUILD_BRIDGE

  1473. void CarlaEngine::setOscBridgeData(const CarlaOscData* const oscData) const noexcept

  1474. {

  1475.     pData->oscData = oscData;

  1476. }

  1477. #endif

  1478. 

  1479. // -----------------------------------------------------------------------

  1480. // Helper functions

  1481. 

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

  1483. {

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

  1485. }

  1486. 

  1487. void CarlaEngine::registerEnginePlugin(const uint id, CarlaPlugin* const plugin) noexcept

  1488. {

  1489.     CARLA_SAFE_ASSERT_RETURN(id == pData->curPluginCount,);

  1490.     carla_debug("CarlaEngine::registerEnginePlugin(%i, %p)", id, plugin);

  1491. 

  1492.     pData->plugins[id].plugin = plugin;

  1493. }

  1494. 

  1495. // -----------------------------------------------------------------------

  1496. // Internal stuff

  1497. 

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

  1499. {

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

  1501. 

  1502. #ifndef BUILD_BRIDGE

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

  1504. #endif

  1505. 

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

  1507.     {

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

  1509. 

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

  1511.             plugin->bufferSizeChanged(newBufferSize);

  1512.     }

  1513. 

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

  1515. }

  1516. 

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

  1518. {

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

  1520. 

  1521. #ifndef BUILD_BRIDGE

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

  1523. #endif

  1524. 

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

  1526.     {

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

  1528. 

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

  1530.             plugin->sampleRateChanged(newSampleRate);

  1531.     }

  1532. 

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

  1534. }

  1535. 

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

  1537. {

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

  1539. 

  1540. #ifndef BUILD_BRIDGE

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

  1542. #endif

  1543. 

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

  1545.     {

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

  1547. 

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

  1549.             plugin->offlineModeChanged(isOfflineNow);

  1550.     }

  1551. }

  1552. 

  1553. void CarlaEngine::runPendingRtEvents() noexcept

  1554. {

  1555.     pData->doNextPluginAction(true);

  1556. 

  1557.     if (pData->time.playing)

  1558.         pData->time.frame += pData->bufferSize;

  1559. 

  1560.     if (pData->options.transportMode == ENGINE_TRANSPORT_MODE_INTERNAL)

  1561.     {

  1562.         pData->timeInfo.playing = pData->time.playing;

  1563.         pData->timeInfo.frame   = pData->time.frame;

  1564.     }

  1565. }

  1566. 

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

  1568. {

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

  1570. 

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

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

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

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

  1575. }

  1576. 

  1577. // -----------------------------------------------------------------------

  1578. 

  1579. CARLA_BACKEND_END_NAMESPACE