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

1589 lines
63KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2020 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. #ifndef BUILD_BRIDGE

  19. # error This file should not be compiled if not building bridge

  20. #endif

  21. 

  22. #include "CarlaEngineClient.hpp"

  23. #include "CarlaEngineInit.hpp"

  24. #include "CarlaPlugin.hpp"

  25. 

  26. #include "CarlaBackendUtils.hpp"

  27. #include "CarlaBase64Utils.hpp"

  28. #include "CarlaBridgeUtils.hpp"

  29. #include "CarlaMIDI.h"

  30. 

  31. #ifdef __SSE2_MATH__

  32. # include <xmmintrin.h>

  33. #endif

  34. 

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

  36. #include "water/misc/Time.h"

  37. 

  38. // must be last

  39. #include "jackbridge/JackBridge.hpp"

  40. 

  41. using water::File;

  42. using water::MemoryBlock;

  43. using water::String;

  44. using water::Time;

  45. 

  46. CARLA_BACKEND_START_NAMESPACE

  47. 

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

  49. 

  50. // just want to access private options...

  51. struct CarlaPlugin::ProtectedData {

  52.     CarlaEngine* const engine;

  53.     CarlaEngineClient* client;

  54.     uint id, hints, options;

  55.     // ...etc

  56. };

  57. 

  58. // -----------------------------------------------------------------------

  59. // Bridge Engine client

  60. 

  61. struct LatencyChangedCallback {

  62.     virtual ~LatencyChangedCallback() noexcept {}

  63.     virtual void latencyChanged(const uint32_t samples) noexcept = 0;

  64. };

  65. 

  66. class CarlaEngineBridgeClient : public CarlaEngineClientForSubclassing

  67. {

  68. public:

  69. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  70.     CarlaEngineBridgeClient(const CarlaEngine& engine,

  71.                             EngineInternalGraph& egraph,

  72.                             const CarlaPluginPtr plugin,

  73.                             LatencyChangedCallback* const cb)

  74.         : CarlaEngineClientForSubclassing(engine, egraph, plugin),

  75.           fLatencyCallback(cb) {}

  76. #else

  77.     CarlaEngineBridgeClient(const CarlaEngine& engine, LatencyChangedCallback* const cb)

  78.         : CarlaEngineClientForSubclassing(engine),

  79.           fLatencyCallback(cb) {}

  80. #endif

  81. 

  82. protected:

  83.     void setLatency(const uint32_t samples) noexcept override

  84.     {

  85.         if (getLatency() == samples)

  86.             return;

  87. 

  88.         fLatencyCallback->latencyChanged(samples);

  89.         CarlaEngineClient::setLatency(samples);

  90.     }

  91. 

  92. private:

  93.     LatencyChangedCallback* const fLatencyCallback;

  94. 

  95.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  96. };

  97. 

  98. // -------------------------------------------------------------------

  99. 

  100. class CarlaEngineBridge : public CarlaEngine,

  101.                           private CarlaThread,

  102.                           private LatencyChangedCallback

  103. {

  104. public:

  105.     CarlaEngineBridge(const char* const audioPoolBaseName, const char* const rtClientBaseName, const char* const nonRtClientBaseName, const char* const nonRtServerBaseName)

  106.         : CarlaEngine(),

  107.           CarlaThread("CarlaEngineBridge"),

  108.           fShmAudioPool(),

  109.           fShmRtClientControl(),

  110.           fShmNonRtClientControl(),

  111.           fShmNonRtServerControl(),

  112.           fBaseNameAudioPool(audioPoolBaseName),

  113.           fBaseNameRtClientControl(rtClientBaseName),

  114.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  115.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  116.           fClosingDown(false),

  117.           fIsOffline(false),

  118.           fFirstIdle(true),

  119.           fLastPingTime(-1)

  120.     {

  121.         carla_debug("CarlaEngineBridge::CarlaEngineBridge(\"%s\", \"%s\", \"%s\", \"%s\")", audioPoolBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);

  122.     }

  123. 

  124.     ~CarlaEngineBridge() noexcept override

  125.     {

  126.         carla_debug("CarlaEngineBridge::~CarlaEngineBridge()");

  127. 

  128.         clear();

  129.     }

  130. 

  131.     // -------------------------------------

  132.     // CarlaEngine virtual calls

  133. 

  134.     bool init(const char* const clientName) override

  135.     {

  136.         carla_debug("CarlaEngineBridge::init(\"%s\")", clientName);

  137. 

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

  139.         {

  140.             setLastError("Failed to init internal data");

  141.             return false;

  142.         }

  143. 

  144.         if (! fShmAudioPool.attachClient(fBaseNameAudioPool))

  145.         {

  146.             pData->close();

  147.             setLastError("Failed to attach to audio pool shared memory");

  148.             return false;

  149.         }

  150. 

  151.         if (! fShmRtClientControl.attachClient(fBaseNameRtClientControl))

  152.         {

  153.             pData->close();

  154.             clear();

  155.             setLastError("Failed to attach to rt client control shared memory");

  156.             return false;

  157.         }

  158. 

  159.         if (! fShmRtClientControl.mapData())

  160.         {

  161.             pData->close();

  162.             clear();

  163.             setLastError("Failed to map rt client control shared memory");

  164.             return false;

  165.         }

  166. 

  167.         if (! fShmNonRtClientControl.attachClient(fBaseNameNonRtClientControl))

  168.         {

  169.             pData->close();

  170.             clear();

  171.             setLastError("Failed to attach to non-rt client control shared memory");

  172.             return false;

  173.         }

  174. 

  175.         if (! fShmNonRtClientControl.mapData())

  176.         {

  177.             pData->close();

  178.             clear();

  179.             setLastError("Failed to map non-rt control client shared memory");

  180.             return false;

  181.         }

  182. 

  183.         if (! fShmNonRtServerControl.attachClient(fBaseNameNonRtServerControl))

  184.         {

  185.             pData->close();

  186.             clear();

  187.             setLastError("Failed to attach to non-rt server control shared memory");

  188.             return false;

  189.         }

  190. 

  191.         if (! fShmNonRtServerControl.mapData())

  192.         {

  193.             pData->close();

  194.             clear();

  195.             setLastError("Failed to map non-rt control server shared memory");

  196.             return false;

  197.         }

  198. 

  199.         PluginBridgeNonRtClientOpcode opcode;

  200. 

  201.         opcode = fShmNonRtClientControl.readOpcode();

  202.         CARLA_SAFE_ASSERT_RETURN(opcode == kPluginBridgeNonRtClientVersion, false);

  203. 

  204.         const uint32_t apiVersion = fShmNonRtClientControl.readUInt();

  205.         CARLA_SAFE_ASSERT_RETURN(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM, false);

  206. 

  207.         const uint32_t shmRtClientDataSize = fShmNonRtClientControl.readUInt();

  208.         CARLA_SAFE_ASSERT_INT2(shmRtClientDataSize == sizeof(BridgeRtClientData), shmRtClientDataSize, sizeof(BridgeRtClientData));

  209. 

  210.         const uint32_t shmNonRtClientDataSize = fShmNonRtClientControl.readUInt();

  211.         CARLA_SAFE_ASSERT_INT2(shmNonRtClientDataSize == sizeof(BridgeNonRtClientData), shmNonRtClientDataSize, sizeof(BridgeNonRtClientData));

  212. 

  213.         const uint32_t shmNonRtServerDataSize = fShmNonRtClientControl.readUInt();

  214.         CARLA_SAFE_ASSERT_INT2(shmNonRtServerDataSize == sizeof(BridgeNonRtServerData), shmNonRtServerDataSize, sizeof(BridgeNonRtServerData));

  215. 

  216.         if (shmRtClientDataSize != sizeof(BridgeRtClientData) ||

  217.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  218.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  219.         {

  220.             pData->close();

  221.             clear();

  222.             setLastError("Shared memory data size mismatch");

  223.             return false;

  224.         }

  225. 

  226.         opcode = fShmNonRtClientControl.readOpcode();

  227.         CARLA_SAFE_ASSERT_RETURN(opcode == kPluginBridgeNonRtClientInitialSetup, false);

  228. 

  229.         pData->bufferSize = fShmNonRtClientControl.readUInt();

  230.         pData->sampleRate = fShmNonRtClientControl.readDouble();

  231. 

  232.         if (pData->bufferSize == 0 || carla_isZero(pData->sampleRate))

  233.         {

  234.             pData->close();

  235.             clear();

  236.             setLastError("Shared memory has invalid data");

  237.             return false;

  238.         }

  239. 

  240.         pData->initTime(nullptr);

  241. 

  242.         // tell backend we're live

  243.         {

  244.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  245. 

  246.             // kPluginBridgeNonRtServerVersion was added in API 7

  247.             if (apiVersion >= 7)

  248.             {

  249.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  250.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  251.             }

  252.             else

  253.             {

  254.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  255.             }

  256. 

  257.             fShmNonRtServerControl.commitWrite();

  258.         }

  259. 

  260.         startThread(true);

  261.         return true;

  262.     }

  263. 

  264.     bool close() override

  265.     {

  266.         carla_debug("CarlaEngineBridge::close()");

  267.         fLastPingTime = -1;

  268. 

  269.         CarlaEngine::close();

  270. 

  271.         stopThread(5000);

  272.         clear();

  273. 

  274.         return true;

  275.     }

  276. 

  277.     bool isRunning() const noexcept override

  278.     {

  279.         if (fClosingDown)

  280.             return false;

  281. 

  282.         return isThreadRunning() || ! fFirstIdle;

  283.     }

  284. 

  285.     bool isOffline() const noexcept override

  286.     {

  287.         return fIsOffline;

  288.     }

  289. 

  290.     EngineType getType() const noexcept override

  291.     {

  292.         return kEngineTypeBridge;

  293.     }

  294. 

  295.     const char* getCurrentDriverName() const noexcept override

  296.     {

  297.         return "Bridge";

  298.     }

  299. 

  300.     void touchPluginParameter(const uint id, const uint32_t parameterId, const bool touch) noexcept override

  301.     {

  302.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  303. 

  304.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  305.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  306.         fShmNonRtServerControl.writeUInt(parameterId);

  307.         fShmNonRtServerControl.writeBool(touch);

  308.         fShmNonRtServerControl.commitWrite();

  309.     }

  310. 

  311.     CarlaEngineClient* addClient(const CarlaPluginPtr plugin) override

  312.     {

  313. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  314.         return new CarlaEngineBridgeClient(*this, pData->graph, plugin, this);

  315. #else

  316.         return new CarlaEngineBridgeClient(*this, this);

  317. 

  318.         // unused

  319.         (void)plugin;

  320. #endif

  321.     }

  322. 

  323.     void idle() noexcept override

  324.     {

  325.         const CarlaPluginPtr plugin = pData->plugins[0].plugin;

  326. 

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

  328.         {

  329.             if (const uint32_t length = static_cast<uint32_t>(pData->lastError.length()))

  330.             {

  331.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  332.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  333.                 fShmNonRtServerControl.writeUInt(length);

  334.                 fShmNonRtServerControl.writeCustomData(pData->lastError.buffer(), length);

  335.                 fShmNonRtServerControl.commitWrite();

  336.             }

  337. 

  338.             signalThreadShouldExit();

  339.             callback(true, true, ENGINE_CALLBACK_QUIT, 0, 0, 0, 0, 0.0f, nullptr);

  340.             return;

  341.         }

  342. 

  343.         const bool wasFirstIdle(fFirstIdle);

  344. 

  345.         if (wasFirstIdle)

  346.         {

  347.             fFirstIdle = false;

  348.             fLastPingTime = Time::currentTimeMillis();

  349.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  350. 

  351.             char bufStr[STR_MAX+1];

  352.             carla_zeroChars(bufStr, STR_MAX+1);

  353. 

  354.             uint32_t bufStrSize;

  355. 

  356.             const CarlaEngineClient* const client(plugin->getEngineClient());

  357.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  358. 

  359.             // kPluginBridgeNonRtServerPluginInfo1

  360.             {

  361.                 // uint/category, uint/hints, uint/optionsAvailable, uint/optionsEnabled, long/uniqueId

  362.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

  363.                 fShmNonRtServerControl.writeUInt(plugin->getCategory());

  364.                 fShmNonRtServerControl.writeUInt(plugin->getHints());

  365.                 fShmNonRtServerControl.writeUInt(plugin->getOptionsAvailable());

  366.                 fShmNonRtServerControl.writeUInt(plugin->getOptionsEnabled());

  367.                 fShmNonRtServerControl.writeLong(plugin->getUniqueId());

  368.                 fShmNonRtServerControl.commitWrite();

  369.             }

  370. 

  371.             // kPluginBridgeNonRtServerPluginInfo2

  372.             {

  373.                 // uint/size, str[] (realName), uint/size, str[] (label), uint/size, str[] (maker), uint/size, str[] (copyright)

  374.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  375. 

  376.                 if (! plugin->getRealName(bufStr))

  377.                     bufStr[0] = '\0';

  378.                 bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));

  379.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  380.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  381. 

  382.                 if (! plugin->getLabel(bufStr))

  383.                     bufStr[0] = '\0';

  384.                 bufStrSize = carla_fixedValue(1U, 256U, static_cast<uint32_t>(std::strlen(bufStr)));

  385.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  386.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  387. 

  388.                 if (! plugin->getMaker(bufStr))

  389.                     bufStr[0] = '\0';

  390.                 bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));

  391.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  392.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  393. 

  394.                 if (! plugin->getCopyright(bufStr))

  395.                     bufStr[0] = '\0';

  396.                 bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));

  397.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  398.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  399. 

  400.                 fShmNonRtServerControl.commitWrite();

  401.             }

  402. 

  403.             // kPluginBridgeNonRtServerAudioCount

  404.             {

  405.                 const uint32_t aIns  = plugin->getAudioInCount();

  406.                 const uint32_t aOuts = plugin->getAudioOutCount();

  407. 

  408.                 // uint/ins, uint/outs

  409.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  410.                 fShmNonRtServerControl.writeUInt(aIns);

  411.                 fShmNonRtServerControl.writeUInt(aOuts);

  412.                 fShmNonRtServerControl.commitWrite();

  413. 

  414.                 // kPluginBridgeNonRtServerPortName

  415.                 for (uint32_t i=0; i<aIns; ++i)

  416.                 {

  417.                     const char* const portName(client->getAudioPortName(true, i));

  418.                     CARLA_SAFE_ASSERT_CONTINUE(portName != nullptr && portName[0] != '\0');

  419. 

  420.                     // byte/type, uint/index, uint/size, str[] (name)

  421.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  422.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  423.                     fShmNonRtServerControl.writeUInt(i);

  424. 

  425.                     bufStrSize = static_cast<uint32_t>(std::strlen(portName));

  426.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  427.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  428.                 }

  429. 

  430.                 // kPluginBridgeNonRtServerPortName

  431.                 for (uint32_t i=0; i<aOuts; ++i)

  432.                 {

  433.                     const char* const portName(client->getAudioPortName(false, i));

  434.                     CARLA_SAFE_ASSERT_CONTINUE(portName != nullptr && portName[0] != '\0');

  435. 

  436.                     // byte/type, uint/index, uint/size, str[] (name)

  437.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  438.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  439.                     fShmNonRtServerControl.writeUInt(i);

  440. 

  441.                     bufStrSize = static_cast<uint32_t>(std::strlen(portName));

  442.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  443.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  444.                 }

  445.             }

  446. 

  447.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  448. 

  449.             // kPluginBridgeNonRtServerMidiCount

  450.             {

  451.                 // uint/ins, uint/outs

  452.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

  453.                 fShmNonRtServerControl.writeUInt(plugin->getMidiInCount());

  454.                 fShmNonRtServerControl.writeUInt(plugin->getMidiOutCount());

  455.                 fShmNonRtServerControl.commitWrite();

  456.             }

  457. 

  458.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  459. 

  460.             // kPluginBridgeNonRtServerCvCount

  461.             {

  462.                 // uint/ins, uint/outs

  463.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

  464.                 fShmNonRtServerControl.writeUInt(plugin->getCVInCount());

  465.                 fShmNonRtServerControl.writeUInt(plugin->getCVOutCount());

  466.                 fShmNonRtServerControl.commitWrite();

  467.             }

  468. 

  469.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  470. 

  471.             // kPluginBridgeNonRtServerParameter*

  472.             if (const uint32_t count = std::min(pData->options.maxParameters, plugin->getParameterCount()))

  473.             {

  474.                 // uint/count

  475.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  476.                 fShmNonRtServerControl.writeUInt(count);

  477.                 fShmNonRtServerControl.commitWrite();

  478. 

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

  480.                 {

  481.                     const ParameterData& paramData(plugin->getParameterData(i));

  482. 

  483.                     if (paramData.type != PARAMETER_INPUT && paramData.type != PARAMETER_OUTPUT)

  484.                         continue;

  485.                     if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)

  486.                         continue;

  487. 

  488.                     // kPluginBridgeNonRtServerParameterData1

  489.                     {

  490.                         // uint/index, int/rindex, uint/type, uint/hints, short/cc

  491.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  492.                         fShmNonRtServerControl.writeUInt(i);

  493.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  494.                         fShmNonRtServerControl.writeUInt(paramData.type);

  495.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  496.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  497.                         fShmNonRtServerControl.commitWrite();

  498.                     }

  499. 

  500.                     // kPluginBridgeNonRtServerParameterData2

  501.                     {

  502.                         // uint/index, uint/size, str[] (name), uint/size, str[] (symbol), uint/size, str[] (unit)

  503.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  504.                         fShmNonRtServerControl.writeUInt(i);

  505. 

  506.                         if (! plugin->getParameterName(i, bufStr))

  507.                             std::snprintf(bufStr, STR_MAX, "Param %u", i+1);

  508.                         bufStrSize = carla_fixedValue(1U, 32U, static_cast<uint32_t>(std::strlen(bufStr)));

  509.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  510.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  511. 

  512.                         if (! plugin->getParameterSymbol(i, bufStr))

  513.                             bufStr[0] = '\0';

  514.                         bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));

  515.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  516.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  517. 

  518.                         if (! plugin->getParameterUnit(i, bufStr))

  519.                             bufStr[0] = '\0';

  520.                         bufStrSize = carla_fixedValue(1U, 32U, static_cast<uint32_t>(std::strlen(bufStr)));

  521.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  522.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  523. 

  524.                         fShmNonRtServerControl.commitWrite();

  525.                     }

  526. 

  527.                     // kPluginBridgeNonRtServerParameterRanges

  528.                     {

  529.                         const ParameterRanges& paramRanges(plugin->getParameterRanges(i));

  530. 

  531.                         // uint/index, float/def, float/min, float/max, float/step, float/stepSmall, float/stepLarge

  532.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  533.                         fShmNonRtServerControl.writeUInt(i);

  534.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  535.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  536.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  537.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  538.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  539.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  540.                         fShmNonRtServerControl.commitWrite();

  541.                     }

  542. 

  543.                     // kPluginBridgeNonRtServerParameterValue2

  544.                     {

  545.                         // uint/index float/value (used for init/output parameters only, don't resend values)

  546.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  547.                         fShmNonRtServerControl.writeUInt(i);

  548.                         fShmNonRtServerControl.writeFloat(plugin->getParameterValue(i));

  549.                         fShmNonRtServerControl.commitWrite();

  550.                     }

  551. 

  552.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  553.                 }

  554.             }

  555. 

  556.             // kPluginBridgeNonRtServerProgram*

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

  558.             {

  559.                 // uint/count

  560.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  561.                 fShmNonRtServerControl.writeUInt(count);

  562.                 fShmNonRtServerControl.commitWrite();

  563. 

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

  565.                 {

  566.                     // uint/index, uint/size, str[] (name)

  567.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  568.                     fShmNonRtServerControl.writeUInt(i);

  569. 

  570.                     if (! plugin->getProgramName(i, bufStr))

  571.                         bufStr[0] = '\0';

  572.                     bufStrSize = carla_fixedValue(1U, 32U, static_cast<uint32_t>(std::strlen(bufStr)));

  573.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  574.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  575. 

  576.                     fShmNonRtServerControl.commitWrite();

  577.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  578.                 }

  579.             }

  580. 

  581.             // kPluginBridgeNonRtServerMidiProgram*

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

  583.             {

  584.                 // uint/count

  585.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  586.                 fShmNonRtServerControl.writeUInt(count);

  587.                 fShmNonRtServerControl.commitWrite();

  588. 

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

  590.                 {

  591.                     const MidiProgramData& mpData(plugin->getMidiProgramData(i));

  592.                     CARLA_SAFE_ASSERT_CONTINUE(mpData.name != nullptr);

  593. 

  594.                     // uint/index, uint/bank, uint/program, uint/size, str[] (name)

  595.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  596.                     fShmNonRtServerControl.writeUInt(i);

  597.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  598.                     fShmNonRtServerControl.writeUInt(mpData.program);

  599. 

  600.                     bufStrSize = carla_fixedValue(1U, 32U, static_cast<uint32_t>(std::strlen(mpData.name)));

  601.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  602.                     fShmNonRtServerControl.writeCustomData(mpData.name, bufStrSize);

  603. 

  604.                     fShmNonRtServerControl.commitWrite();

  605.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  606.                 }

  607.             }

  608. 

  609.             if (const uint32_t latency = plugin->getLatencyInFrames())

  610.             {

  611.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  612.                 fShmNonRtServerControl.writeUInt(latency);

  613.                 fShmNonRtServerControl.commitWrite();

  614.             }

  615. 

  616.             // ready!

  617.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  618.             fShmNonRtServerControl.commitWrite();

  619.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  620. 

  621.             carla_stdout("Carla Bridge Ready!");

  622.             fLastPingTime = Time::currentTimeMillis();

  623.         }

  624. 

  625.         // send parameter outputs

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

  627.         {

  628.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  629. 

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

  631.             {

  632.                 if (! plugin->isParameterOutput(i))

  633.                     continue;

  634. 

  635.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  636.                 fShmNonRtServerControl.writeUInt(i);

  637.                 fShmNonRtServerControl.writeFloat(plugin->getParameterValue(i));

  638. 

  639.                 // parameter outputs are not that important, we can skip some

  640.                 if (! fShmNonRtServerControl.commitWrite())

  641.                     break;

  642.             }

  643.         }

  644. 

  645.         CarlaEngine::idle();

  646. 

  647.         try {

  648.             handleNonRtData();

  649.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  650. 

  651.         if (fLastPingTime > 0 && Time::currentTimeMillis() > fLastPingTime + 30000 && ! wasFirstIdle)

  652.         {

  653.             carla_stderr("Did not receive ping message from server for 30 secs, closing...");

  654.             signalThreadShouldExit();

  655.             callback(true, true, ENGINE_CALLBACK_QUIT, 0, 0, 0, 0, 0.0f, nullptr);

  656.         }

  657.     }

  658. 

  659.     void callback(const bool sendHost, const bool sendOsc,

  660.                   const EngineCallbackOpcode action, const uint pluginId,

  661.                   const int value1, const int value2, const int value3,

  662.                   const float valuef, const char* const valueStr) noexcept override

  663.     {

  664.         CarlaEngine::callback(sendHost, sendOsc, action, pluginId, value1, value2, value3, valuef, valueStr);

  665. 

  666.         if (fClosingDown || ! sendHost)

  667.             return;

  668. 

  669.         switch (action)

  670.         {

  671.         // uint/index float/value

  672.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  673.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  674.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  675.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  676.             fShmNonRtServerControl.writeUInt(static_cast<uint>(value1));

  677.             fShmNonRtServerControl.writeFloat(valuef);

  678.             fShmNonRtServerControl.commitWrite();

  679.         }   break;

  680. 

  681.         // uint/index float/value

  682.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  683.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  684.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  685.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

  686.             fShmNonRtServerControl.writeUInt(static_cast<uint>(value1));

  687.             fShmNonRtServerControl.writeFloat(valuef);

  688.             fShmNonRtServerControl.commitWrite();

  689.         }   break;

  690. 

  691.         // int/index

  692.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  693.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  694.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  695.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  696.             fShmNonRtServerControl.writeInt(value1);

  697.             fShmNonRtServerControl.commitWrite();

  698.         }   break;

  699. 

  700.         // int/index

  701.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  702.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  703.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  704.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  705.             fShmNonRtServerControl.writeInt(value1);

  706.             fShmNonRtServerControl.commitWrite();

  707.         }   break;

  708. 

  709.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  710.             if (value1 != 1)

  711.             {

  712.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  713.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  714.                 fShmNonRtServerControl.commitWrite();

  715.             }

  716.             break;

  717. 

  718.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  719.             if (const CarlaPluginPtr plugin = pData->plugins[0].plugin)

  720.             {

  721.                 if (const uint32_t count = std::min(pData->options.maxParameters, plugin->getParameterCount()))

  722.                 {

  723.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  724. 

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

  726.                     {

  727.                         const ParameterData& paramData(plugin->getParameterData(i));

  728. 

  729.                         if (paramData.type != PARAMETER_INPUT && paramData.type != PARAMETER_OUTPUT)

  730.                             continue;

  731.                         if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)

  732.                             continue;

  733. 

  734.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  735.                         fShmNonRtServerControl.writeUInt(i);

  736.                         fShmNonRtServerControl.writeFloat(plugin->getParameterValue(i));

  737.                         fShmNonRtServerControl.commitWrite();

  738. 

  739.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  740.                     }

  741.                 }

  742.             }

  743.             break;

  744. 

  745.         default:

  746.             break;

  747.         }

  748.     }

  749. 

  750.     // -------------------------------------------------------------------

  751. 

  752.     void clear() noexcept

  753.     {

  754.         fShmAudioPool.clear();

  755.         fShmRtClientControl.clear();

  756.         fShmNonRtClientControl.clear();

  757.         fShmNonRtServerControl.clear();

  758.     }

  759. 

  760.     void handleNonRtData()

  761.     {

  762.         const CarlaPluginPtr plugin = pData->plugins[0].plugin;

  763.         CARLA_SAFE_ASSERT_RETURN(plugin.get() != nullptr,);

  764. 

  765.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  766.         {

  767.             const PluginBridgeNonRtClientOpcode opcode = fShmNonRtClientControl.readOpcode();

  768. 

  769. #ifdef DEBUG

  770.             if (opcode != kPluginBridgeNonRtClientPing) {

  771.                 carla_debug("CarlaEngineBridge::handleNonRtData() - got opcode: %i:%s",

  772.                             opcode, PluginBridgeNonRtClientOpcode2str(opcode));

  773.             }

  774. #endif

  775. 

  776.             if (opcode != kPluginBridgeNonRtClientNull && opcode != kPluginBridgeNonRtClientPingOnOff && fLastPingTime > 0)

  777.                 fLastPingTime = Time::currentTimeMillis();

  778. 

  779.             switch (opcode)

  780.             {

  781.             case kPluginBridgeNonRtClientNull:

  782.                 break;

  783. 

  784.             case kPluginBridgeNonRtClientVersion: {

  785.                 const uint apiVersion = fShmNonRtServerControl.readUInt();

  786.                 CARLA_SAFE_ASSERT_UINT2(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  787.                                         apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  788.             }   break;

  789. 

  790.             case kPluginBridgeNonRtClientPing: {

  791.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  792. 

  793.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  794.                 fShmNonRtServerControl.commitWrite();

  795.             }   break;

  796. 

  797.             case kPluginBridgeNonRtClientPingOnOff: {

  798.                 const uint32_t onOff(fShmNonRtClientControl.readBool());

  799. 

  800.                 fLastPingTime = onOff ? Time::currentTimeMillis() : -1;

  801.             }   break;

  802. 

  803.             case kPluginBridgeNonRtClientActivate:

  804.                 if (plugin->isEnabled())

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

  806.                 break;

  807. 

  808.             case kPluginBridgeNonRtClientDeactivate:

  809.                 if (plugin->isEnabled())

  810.                     plugin->setActive(false, false, false);

  811.                 break;

  812. 

  813.             case kPluginBridgeNonRtClientInitialSetup:

  814.                 // should never happen!!

  815.                 fShmNonRtServerControl.readUInt();

  816.                 fShmNonRtServerControl.readDouble();

  817.                 break;

  818. 

  819.             case kPluginBridgeNonRtClientSetParameterValue: {

  820.                 const uint32_t index(fShmNonRtClientControl.readUInt());

  821.                 const float    value(fShmNonRtClientControl.readFloat());

  822. 

  823.                 if (plugin->isEnabled())

  824.                     plugin->setParameterValue(index, value, false, false, false);

  825.                 break;

  826.             }

  827. 

  828.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

  829.                 const uint32_t index(fShmNonRtClientControl.readUInt());

  830.                 const uint8_t  channel(fShmNonRtClientControl.readByte());

  831. 

  832.                 if (plugin->isEnabled())

  833.                     plugin->setParameterMidiChannel(index, channel, false, false);

  834.                 break;

  835.             }

  836. 

  837.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

  838.                 const uint32_t index(fShmNonRtClientControl.readUInt());

  839.                 const int16_t  ctrl(fShmNonRtClientControl.readShort());

  840. 

  841.                 if (plugin->isEnabled())

  842.                     plugin->setParameterMappedControlIndex(index, ctrl, false, false, true);

  843.                 break;

  844.             }

  845. 

  846.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

  847.                 const uint32_t index   = fShmNonRtClientControl.readUInt();

  848.                 const float    minimum = fShmNonRtClientControl.readFloat();

  849.                 const float    maximum = fShmNonRtClientControl.readFloat();

  850. 

  851.                 if (plugin->isEnabled())

  852.                     plugin->setParameterMappedRange(index, minimum, maximum, false, false);

  853.                 break;

  854.             }

  855. 

  856.             case kPluginBridgeNonRtClientSetProgram: {

  857.                 const int32_t index(fShmNonRtClientControl.readInt());

  858. 

  859.                 if (plugin->isEnabled())

  860.                     plugin->setProgram(index, true, false, false);

  861.                 break;

  862.             }

  863. 

  864.             case kPluginBridgeNonRtClientSetMidiProgram: {

  865.                 const int32_t index(fShmNonRtClientControl.readInt());

  866. 

  867.                 if (plugin->isEnabled())

  868.                     plugin->setMidiProgram(index, true, false, false);

  869.                 break;

  870.             }

  871. 

  872.             case kPluginBridgeNonRtClientSetCustomData: {

  873.                 // type

  874.                 const uint32_t typeSize(fShmNonRtClientControl.readUInt());

  875.                 char typeStr[typeSize+1];

  876.                 carla_zeroChars(typeStr, typeSize+1);

  877.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  878. 

  879.                 // key

  880.                 const uint32_t keySize(fShmNonRtClientControl.readUInt());

  881.                 char keyStr[keySize+1];

  882.                 carla_zeroChars(keyStr, keySize+1);

  883.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  884. 

  885.                 // value

  886.                 const uint32_t valueSize(fShmNonRtClientControl.readUInt());

  887.                 char valueStr[valueSize+1];

  888.                 carla_zeroChars(valueStr, valueSize+1);

  889. 

  890.                 if (valueSize > 0)

  891.                     fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  892. 

  893.                 if (plugin->isEnabled())

  894.                     plugin->setCustomData(typeStr, keyStr, valueStr, true);

  895.                 break;

  896.             }

  897. 

  898.             case kPluginBridgeNonRtClientSetChunkDataFile: {

  899.                 const uint32_t size(fShmNonRtClientControl.readUInt());

  900.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  901. 

  902.                 char chunkFilePathTry[size+1];

  903.                 carla_zeroChars(chunkFilePathTry, size+1);

  904.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  905. 

  906.                 CARLA_SAFE_ASSERT_BREAK(chunkFilePathTry[0] != '\0');

  907.                 if (! plugin->isEnabled()) break;

  908. 

  909.                 String chunkFilePath(chunkFilePathTry);

  910. 

  911. #ifdef CARLA_OS_WIN

  912.                 // check if running under Wine

  913.                 if (chunkFilePath.startsWith("/"))

  914.                     chunkFilePath = chunkFilePath.replaceSection(0, 1, "Z:\\").replace("/", "\\");

  915. #endif

  916. 

  917.                 File chunkFile(chunkFilePath);

  918.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  919. 

  920.                 String chunkDataBase64(chunkFile.loadFileAsString());

  921.                 chunkFile.deleteFile();

  922.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  923. 

  924.                 std::vector<uint8_t> chunk(carla_getChunkFromBase64String(chunkDataBase64.toRawUTF8()));

  925. 

  926. #ifdef CARLA_PROPER_CPP11_SUPPORT

  927.                 plugin->setChunkData(chunk.data(), chunk.size());

  928. #else

  929.                 plugin->setChunkData(&chunk.front(), chunk.size());

  930. #endif

  931.                 break;

  932.             }

  933. 

  934.             case kPluginBridgeNonRtClientSetCtrlChannel: {

  935.                 const int16_t channel(fShmNonRtClientControl.readShort());

  936.                 CARLA_SAFE_ASSERT_BREAK(channel >= -1 && channel < MAX_MIDI_CHANNELS);

  937. 

  938.                 if (plugin->isEnabled())

  939.                     plugin->setCtrlChannel(static_cast<int8_t>(channel), false, false);

  940.                 break;

  941.             }

  942. 

  943.             case kPluginBridgeNonRtClientSetOption: {

  944.                 const uint32_t option(fShmNonRtClientControl.readUInt());

  945.                 const bool     yesNo(fShmNonRtClientControl.readBool());

  946. 

  947.                 if (plugin->isEnabled())

  948.                     plugin->setOption(option, yesNo, false);

  949.                 break;

  950.             }

  951. 

  952.             case kPluginBridgeNonRtClientSetOptions: {

  953.                 const uint32_t options(fShmNonRtClientControl.readUInt());

  954. 

  955.                 plugin->pData->options = options;

  956.                 break;

  957.             }

  958. 

  959.             case kPluginBridgeNonRtClientSetWindowTitle: {

  960.                 const uint32_t size = fShmNonRtClientControl.readUInt();

  961.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  962. 

  963.                 char title[size+1];

  964.                 carla_zeroChars(title, size+1);

  965.                 fShmNonRtClientControl.readCustomData(title, size);

  966. 

  967.                 plugin->setCustomUITitle(title);

  968.                 break;

  969.             }

  970. 

  971.             case kPluginBridgeNonRtClientGetParameterText: {

  972.                 const int32_t index = fShmNonRtClientControl.readInt();

  973. 

  974.                 if (index >= 0 && plugin->isEnabled())

  975.                 {

  976.                     char bufStr[STR_MAX+1];

  977.                     carla_zeroChars(bufStr, STR_MAX+1);

  978.                     if (! plugin->getParameterText(static_cast<uint32_t>(index), bufStr))

  979.                         bufStr[0] = '\0';

  980. 

  981.                     const uint32_t bufStrLen = static_cast<uint32_t>(std::strlen(bufStr));

  982. 

  983.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  984. 

  985.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  986. 

  987.                     fShmNonRtServerControl.writeInt(index);

  988.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  989.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  990.                     fShmNonRtServerControl.commitWrite();

  991. 

  992.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  993.                 }

  994.                 else

  995.                 {

  996.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  997. 

  998.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  999.                     fShmNonRtServerControl.writeInt(index);

  1000.                     fShmNonRtServerControl.writeUInt(0);

  1001.                     fShmNonRtServerControl.commitWrite();

  1002.                 }

  1003. 

  1004.                 break;

  1005.             }

  1006. 

  1007.             case kPluginBridgeNonRtClientPrepareForSave: {

  1008.                 if (! plugin->isEnabled())

  1009.                 {

  1010.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1011.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1012.                     fShmNonRtServerControl.commitWrite();

  1013.                     return;

  1014.                 }

  1015. 

  1016.                 plugin->prepareForSave(false);

  1017. 

  1018.                 for (uint32_t i=0, count=plugin->getCustomDataCount(); i<count; ++i)

  1019.                 {

  1020.                     const CustomData& cdata(plugin->getCustomData(i));

  1021. 

  1022.                     if (std::strcmp(cdata.type, CUSTOM_DATA_TYPE_PROPERTY) == 0)

  1023.                         continue;

  1024. 

  1025.                     const uint32_t typeLen(static_cast<uint32_t>(std::strlen(cdata.type)));

  1026.                     const uint32_t keyLen(static_cast<uint32_t>(std::strlen(cdata.key)));

  1027.                     const uint32_t valueLen(static_cast<uint32_t>(std::strlen(cdata.value)));

  1028. 

  1029.                     {

  1030.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1031. 

  1032.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1033. 

  1034.                         fShmNonRtServerControl.writeUInt(typeLen);

  1035.                         fShmNonRtServerControl.writeCustomData(cdata.type, typeLen);

  1036. 

  1037.                         fShmNonRtServerControl.writeUInt(keyLen);

  1038.                         fShmNonRtServerControl.writeCustomData(cdata.key, keyLen);

  1039. 

  1040.                         fShmNonRtServerControl.writeUInt(valueLen);

  1041. 

  1042.                         if (valueLen > 0)

  1043.                             fShmNonRtServerControl.writeCustomData(cdata.value, valueLen);

  1044. 

  1045.                         fShmNonRtServerControl.commitWrite();

  1046.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1047.                     }

  1048.                 }

  1049. 

  1050.                 if (plugin->getOptionsEnabled() & PLUGIN_OPTION_USE_CHUNKS)

  1051.                 {

  1052.                     void* data = nullptr;

  1053.                     if (const std::size_t dataSize = plugin->getChunkData(&data))

  1054.                     {

  1055.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1056. 

  1057.                         CarlaString dataBase64 = CarlaString::asBase64(data, dataSize);

  1058.                         CARLA_SAFE_ASSERT_BREAK(dataBase64.length() > 0);

  1059. 

  1060.                         String filePath(File::getSpecialLocation(File::tempDirectory).getFullPathName());

  1061. 

  1062.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1063.                         filePath += fShmAudioPool.getFilenameSuffix();

  1064. 

  1065.                         if (File(filePath).replaceWithText(dataBase64.buffer()))

  1066.                         {

  1067.                             const uint32_t ulength(static_cast<uint32_t>(filePath.length()));

  1068. 

  1069.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1070. 

  1071.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1072.                             fShmNonRtServerControl.writeUInt(ulength);

  1073.                             fShmNonRtServerControl.writeCustomData(filePath.toRawUTF8(), ulength);

  1074.                             fShmNonRtServerControl.commitWrite();

  1075.                         }

  1076.                     }

  1077.                 }

  1078. 

  1079.                 {

  1080.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1081. 

  1082.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1083.                     fShmNonRtServerControl.commitWrite();

  1084.                 }

  1085.                 break;

  1086.             }

  1087. 

  1088.             case kPluginBridgeNonRtClientRestoreLV2State:

  1089.                 if (plugin->isEnabled())

  1090.                     plugin->restoreLV2State(false);

  1091.                 break;

  1092. 

  1093.             case kPluginBridgeNonRtClientShowUI:

  1094.                 if (plugin->isEnabled())

  1095.                     plugin->showCustomUI(true);

  1096.                 break;

  1097. 

  1098.             case kPluginBridgeNonRtClientHideUI:

  1099.                 if (plugin->isEnabled())

  1100.                     plugin->showCustomUI(false);

  1101.                 break;

  1102. 

  1103.             case kPluginBridgeNonRtClientUiParameterChange: {

  1104.                 const uint32_t index(fShmNonRtClientControl.readUInt());

  1105.                 const float    value(fShmNonRtClientControl.readFloat());

  1106. 

  1107.                 if (plugin->isEnabled())

  1108.                     plugin->uiParameterChange(index, value);

  1109.                 break;

  1110.             }

  1111. 

  1112.             case kPluginBridgeNonRtClientUiProgramChange: {

  1113.                 const uint32_t index(fShmNonRtClientControl.readUInt());

  1114. 

  1115.                 if (plugin->isEnabled())

  1116.                     plugin->uiProgramChange(index);

  1117.                 break;

  1118.             }

  1119. 

  1120.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

  1121.                 const uint32_t index(fShmNonRtClientControl.readUInt());

  1122. 

  1123.                 if (plugin->isEnabled())

  1124.                     plugin->uiMidiProgramChange(index);

  1125.                 break;

  1126.             }

  1127. 

  1128.             case kPluginBridgeNonRtClientUiNoteOn: {

  1129.                 const uint8_t chnl(fShmNonRtClientControl.readByte());

  1130.                 const uint8_t note(fShmNonRtClientControl.readByte());

  1131.                 const uint8_t velo(fShmNonRtClientControl.readByte());

  1132. 

  1133.                 if (plugin->isEnabled())

  1134.                     plugin->uiNoteOn(chnl, note, velo);

  1135.                 break;

  1136.             }

  1137. 

  1138.             case kPluginBridgeNonRtClientUiNoteOff: {

  1139.                 const uint8_t chnl(fShmNonRtClientControl.readByte());

  1140.                 const uint8_t note(fShmNonRtClientControl.readByte());

  1141. 

  1142.                 if (plugin->isEnabled())

  1143.                     plugin->uiNoteOff(chnl, note);

  1144.                 break;

  1145.             }

  1146. 

  1147.             case kPluginBridgeNonRtClientQuit:

  1148.                 fClosingDown = true;

  1149.                 signalThreadShouldExit();

  1150.                 callback(true, true, ENGINE_CALLBACK_QUIT, 0, 0, 0, 0, 0.0f, nullptr);

  1151.                 break;

  1152.             }

  1153.         }

  1154.     }

  1155. 

  1156.     // -------------------------------------------------------------------

  1157. 

  1158. protected:

  1159.     void run() override

  1160.     {

  1161. #ifdef __SSE2_MATH__

  1162.         // Set FTZ and DAZ flags

  1163.         _mm_setcsr(_mm_getcsr() | 0x8040);

  1164. #endif

  1165. 

  1166.         bool quitReceived = false;

  1167. 

  1168.         for (; ! shouldThreadExit();)

  1169.         {

  1170.             const BridgeRtClientControl::WaitHelper helper(fShmRtClientControl);

  1171. 

  1172.             if (! helper.ok)

  1173.                 continue;

  1174. 

  1175.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1176.             {

  1177.                 const PluginBridgeRtClientOpcode opcode(fShmRtClientControl.readOpcode());

  1178.                 const CarlaPluginPtr plugin = pData->plugins[0].plugin;

  1179. 

  1180. #ifdef DEBUG

  1181.                 if (opcode != kPluginBridgeRtClientProcess && opcode != kPluginBridgeRtClientMidiEvent) {

  1182.                     carla_debug("CarlaEngineBridgeRtThread::run() - got opcode: %s", PluginBridgeRtClientOpcode2str(opcode));

  1183.                 }

  1184. #endif

  1185. 

  1186.                 switch (opcode)

  1187.                 {

  1188.                 case kPluginBridgeRtClientNull:

  1189.                     break;

  1190. 

  1191.                 case kPluginBridgeRtClientSetAudioPool: {

  1192.                     if (fShmAudioPool.data != nullptr)

  1193.                     {

  1194.                         jackbridge_shm_unmap(fShmAudioPool.shm, fShmAudioPool.data);

  1195.                         fShmAudioPool.data = nullptr;

  1196.                     }

  1197.                     const uint64_t poolSize(fShmRtClientControl.readULong());

  1198.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

  1199.                     fShmAudioPool.data = (float*)jackbridge_shm_map(fShmAudioPool.shm, static_cast<size_t>(poolSize));

  1200.                     break;

  1201.                 }

  1202. 

  1203.                 case kPluginBridgeRtClientSetBufferSize: {

  1204.                     const uint32_t bufferSize(fShmRtClientControl.readUInt());

  1205.                     pData->bufferSize = bufferSize;

  1206.                     bufferSizeChanged(bufferSize);

  1207.                     break;

  1208.                 }

  1209. 

  1210.                 case kPluginBridgeRtClientSetSampleRate: {

  1211.                     const double sampleRate(fShmRtClientControl.readDouble());

  1212.                     pData->sampleRate = sampleRate;

  1213.                     sampleRateChanged(sampleRate);

  1214.                     break;

  1215.                 }

  1216. 

  1217.                 case kPluginBridgeRtClientSetOnline:

  1218.                     fIsOffline = fShmRtClientControl.readBool();

  1219.                     offlineModeChanged(fIsOffline);

  1220.                     break;

  1221. 

  1222.                 // NOTE this is never used

  1223.                 case kPluginBridgeRtClientControlEventParameter: {

  1224.                     const uint32_t time(fShmRtClientControl.readUInt());

  1225.                     const uint8_t  channel(fShmRtClientControl.readByte());

  1226.                     const uint16_t param(fShmRtClientControl.readUShort());

  1227.                     const float    value(fShmRtClientControl.readFloat());

  1228. 

  1229.                     if (EngineEvent* const event = getNextFreeInputEvent())

  1230.                     {

  1231.                         event->type                 = kEngineEventTypeControl;

  1232.                         event->time                 = time;

  1233.                         event->channel              = channel;

  1234.                         event->ctrl.type            = kEngineControlEventTypeParameter;

  1235.                         event->ctrl.param           = param;

  1236.                         event->ctrl.midiValue       = -1;

  1237.                         event->ctrl.normalizedValue = value;

  1238.                         event->ctrl.handled         = true;

  1239.                     }

  1240.                     break;

  1241.                 }

  1242. 

  1243.                 case kPluginBridgeRtClientControlEventMidiBank: {

  1244.                     const uint32_t time(fShmRtClientControl.readUInt());

  1245.                     const uint8_t  channel(fShmRtClientControl.readByte());

  1246.                     const uint16_t index(fShmRtClientControl.readUShort());

  1247. 

  1248.                     if (EngineEvent* const event = getNextFreeInputEvent())

  1249.                     {

  1250.                         event->type                 = kEngineEventTypeControl;

  1251.                         event->time                 = time;

  1252.                         event->channel              = channel;

  1253.                         event->ctrl.type            = kEngineControlEventTypeMidiBank;

  1254.                         event->ctrl.param           = index;

  1255.                         event->ctrl.midiValue       = -1;

  1256.                         event->ctrl.normalizedValue = 0.0f;

  1257.                         event->ctrl.handled         = true;

  1258.                     }

  1259.                     break;

  1260.                 }

  1261. 

  1262.                 case kPluginBridgeRtClientControlEventMidiProgram: {

  1263.                     const uint32_t time(fShmRtClientControl.readUInt());

  1264.                     const uint8_t  channel(fShmRtClientControl.readByte());

  1265.                     const uint16_t index(fShmRtClientControl.readUShort());

  1266. 

  1267.                     if (EngineEvent* const event = getNextFreeInputEvent())

  1268.                     {

  1269.                         event->type                 = kEngineEventTypeControl;

  1270.                         event->time                 = time;

  1271.                         event->channel              = channel;

  1272.                         event->ctrl.type            = kEngineControlEventTypeMidiProgram;

  1273.                         event->ctrl.param           = index;

  1274.                         event->ctrl.midiValue       = -1;

  1275.                         event->ctrl.normalizedValue = 0.0f;

  1276.                         event->ctrl.handled         = true;

  1277.                     }

  1278.                     break;

  1279.                 }

  1280. 

  1281.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

  1282.                     const uint32_t time(fShmRtClientControl.readUInt());

  1283.                     const uint8_t  channel(fShmRtClientControl.readByte());

  1284. 

  1285.                     if (EngineEvent* const event = getNextFreeInputEvent())

  1286.                     {

  1287.                         event->type                 = kEngineEventTypeControl;

  1288.                         event->time                 = time;

  1289.                         event->channel              = channel;

  1290.                         event->ctrl.type            = kEngineControlEventTypeAllSoundOff;

  1291.                         event->ctrl.param           = 0;

  1292.                         event->ctrl.midiValue       = -1;

  1293.                         event->ctrl.normalizedValue = 0.0f;

  1294.                         event->ctrl.handled         = true;

  1295.                     }

  1296.                 }   break;

  1297. 

  1298.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

  1299.                     const uint32_t time(fShmRtClientControl.readUInt());

  1300.                     const uint8_t  channel(fShmRtClientControl.readByte());

  1301. 

  1302.                     if (EngineEvent* const event = getNextFreeInputEvent())

  1303.                     {

  1304.                         event->type                 = kEngineEventTypeControl;

  1305.                         event->time                 = time;

  1306.                         event->channel              = channel;

  1307.                         event->ctrl.type            = kEngineControlEventTypeAllNotesOff;

  1308.                         event->ctrl.param           = 0;

  1309.                         event->ctrl.midiValue       = -1;

  1310.                         event->ctrl.normalizedValue = 0.0f;

  1311.                         event->ctrl.handled         = true;

  1312.                     }

  1313.                 }   break;

  1314. 

  1315.                 case kPluginBridgeRtClientMidiEvent: {

  1316.                     const uint32_t time(fShmRtClientControl.readUInt());

  1317.                     const uint8_t  port(fShmRtClientControl.readByte());

  1318.                     const uint8_t  size(fShmRtClientControl.readByte());

  1319.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1320. 

  1321.                     // FIXME variable-size stack

  1322.                     uint8_t data[size];

  1323. 

  1324.                     for (uint8_t i=0; i<size; ++i)

  1325.                         data[i] = fShmRtClientControl.readByte();

  1326. 

  1327.                     if (EngineEvent* const event = getNextFreeInputEvent())

  1328.                     {

  1329.                         event->type    = kEngineEventTypeMidi;

  1330.                         event->time    = time;

  1331.                         event->channel = MIDI_GET_CHANNEL_FROM_DATA(data);

  1332. 

  1333.                         event->midi.port = port;

  1334.                         event->midi.size = size;

  1335. 

  1336.                         if (size > EngineMidiEvent::kDataSize)

  1337.                         {

  1338.                             event->midi.dataExt = data;

  1339.                             std::memset(event->midi.data, 0, sizeof(uint8_t)*EngineMidiEvent::kDataSize);

  1340.                         }

  1341.                         else

  1342.                         {

  1343.                             event->midi.data[0] = MIDI_GET_STATUS_FROM_DATA(data);

  1344. 

  1345.                             uint8_t i=1;

  1346.                             for (; i < size; ++i)

  1347.                                 event->midi.data[i] = data[i];

  1348.                             for (; i < EngineMidiEvent::kDataSize; ++i)

  1349.                                 event->midi.data[i] = 0;

  1350. 

  1351.                             event->midi.dataExt = nullptr;

  1352.                         }

  1353.                     }

  1354.                     break;

  1355.                 }

  1356. 

  1357.                 case kPluginBridgeRtClientProcess: {

  1358.                     const uint32_t frames(fShmRtClientControl.readUInt());

  1359. 

  1360.                     CARLA_SAFE_ASSERT_BREAK(fShmAudioPool.data != nullptr);

  1361. 

  1362.                     if (plugin.get() != nullptr && plugin->isEnabled() && plugin->tryLock(fIsOffline))

  1363.                     {

  1364.                         const BridgeTimeInfo& bridgeTimeInfo(fShmRtClientControl.data->timeInfo);

  1365. 

  1366.                         const uint32_t audioInCount(plugin->getAudioInCount());

  1367.                         const uint32_t audioOutCount(plugin->getAudioOutCount());

  1368.                         const uint32_t cvInCount(plugin->getCVInCount());

  1369.                         const uint32_t cvOutCount(plugin->getCVOutCount());

  1370. 

  1371.                         const float* audioIn[audioInCount];

  1372.                         /* */ float* audioOut[audioOutCount];

  1373.                         const float* cvIn[cvInCount];

  1374.                         /* */ float* cvOut[cvOutCount];

  1375. 

  1376.                         float* fdata = fShmAudioPool.data;

  1377. 

  1378.                         for (uint32_t i=0; i < audioInCount; ++i, fdata += pData->bufferSize)

  1379.                             audioIn[i] = fdata;

  1380.                         for (uint32_t i=0; i < audioOutCount; ++i, fdata += pData->bufferSize)

  1381.                             audioOut[i] = fdata;

  1382. 

  1383.                         for (uint32_t i=0; i < cvInCount; ++i, fdata += pData->bufferSize)

  1384.                             cvIn[i] = fdata;

  1385.                         for (uint32_t i=0; i < cvOutCount; ++i, fdata += pData->bufferSize)

  1386.                             cvOut[i] = fdata;

  1387. 

  1388.                         EngineTimeInfo& timeInfo(pData->timeInfo);

  1389. 

  1390.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1391.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1392.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

  1393.                         timeInfo.bbt.valid = (bridgeTimeInfo.validFlags & kPluginBridgeTimeInfoValidBBT) != 0;

  1394. 

  1395.                         if (timeInfo.bbt.valid)

  1396.                         {

  1397.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1398.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1399.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1400. 

  1401.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1402.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1403. 

  1404.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1405.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1406.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1407.                         }

  1408. 

  1409.                         plugin->initBuffers();

  1410.                         plugin->process(audioIn, audioOut, cvIn, cvOut, frames);

  1411.                         plugin->unlock();

  1412.                     }

  1413. 

  1414.                     uint8_t* midiData(fShmRtClientControl.data->midiOut);

  1415.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1416.                     std::size_t curMidiDataPos = 0;

  1417. 

  1418.                     if (pData->events.in[0].type != kEngineEventTypeNull)

  1419.                         carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);

  1420. 

  1421.                     if (pData->events.out[0].type != kEngineEventTypeNull)

  1422.                     {

  1423.                         for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)

  1424.                         {

  1425.                             const EngineEvent& event(pData->events.out[i]);

  1426. 

  1427.                             if (event.type == kEngineEventTypeNull)

  1428.                                 break;

  1429. 

  1430.                             if (event.type == kEngineEventTypeControl)

  1431.                             {

  1432.                                 uint8_t data[3];

  1433.                                 const uint8_t size = event.ctrl.convertToMidiData(event.channel, data);

  1434.                                 CARLA_SAFE_ASSERT_CONTINUE(size > 0 && size <= 3);

  1435. 

  1436.                                 if (curMidiDataPos + kBridgeBaseMidiOutHeaderSize + size >= kBridgeRtClientDataMidiOutSize)

  1437.                                     break;

  1438. 

  1439.                                 // set time

  1440.                                 *(uint32_t*)midiData = event.time;

  1441.                                 midiData = midiData + 4;

  1442.                                 curMidiDataPos += 4;

  1443. 

  1444.                                 // set port

  1445.                                 *midiData++ = 0;

  1446.                                 ++curMidiDataPos;

  1447. 

  1448.                                 // set size

  1449.                                 *midiData++ = size;

  1450.                                 ++curMidiDataPos;

  1451. 

  1452.                                 // set data

  1453.                                 for (uint8_t j=0; j<size; ++j)

  1454.                                     *midiData++ = data[j];

  1455. 

  1456.                                 curMidiDataPos += size;

  1457.                             }

  1458.                             else if (event.type == kEngineEventTypeMidi)

  1459.                             {

  1460.                                 const EngineMidiEvent& _midiEvent(event.midi);

  1461. 

  1462.                                 if (curMidiDataPos + kBridgeBaseMidiOutHeaderSize + _midiEvent.size >= kBridgeRtClientDataMidiOutSize)

  1463.                                     break;

  1464. 

  1465.                                 const uint8_t* const _midiData(_midiEvent.dataExt != nullptr ? _midiEvent.dataExt : _midiEvent.data);

  1466. 

  1467.                                 // set time

  1468.                                 *(uint32_t*)midiData = event.time;

  1469.                                 midiData += 4;

  1470.                                 curMidiDataPos += 4;

  1471. 

  1472.                                 // set port

  1473.                                 *midiData++ = _midiEvent.port;

  1474.                                 ++curMidiDataPos;

  1475. 

  1476.                                 // set size

  1477.                                 *midiData++ = _midiEvent.size;

  1478.                                 ++curMidiDataPos;

  1479. 

  1480.                                 // set data

  1481.                                 *midiData++ = uint8_t(_midiData[0] | (event.channel & MIDI_CHANNEL_BIT));

  1482. 

  1483.                                 for (uint8_t j=1; j<_midiEvent.size; ++j)

  1484.                                     *midiData++ = _midiData[j];

  1485. 

  1486.                                 curMidiDataPos += _midiEvent.size;

  1487.                             }

  1488.                         }

  1489. 

  1490.                         if (curMidiDataPos != 0 &&

  1491.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1492.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1493. 

  1494.                         carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);

  1495.                     }

  1496. 

  1497.                 }   break;

  1498. 

  1499.                 case kPluginBridgeRtClientQuit: {

  1500.                     quitReceived = true;

  1501.                     fClosingDown = true;

  1502.                     signalThreadShouldExit();

  1503.                 }   break;

  1504.                 }

  1505.             }

  1506.         }

  1507. 

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

  1509. 

  1510.         if (! quitReceived)

  1511.         {

  1512.             const char* const message("Plugin bridge error, process thread has stopped");

  1513.             const std::size_t messageSize(std::strlen(message));

  1514. 

  1515.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1516.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1517.             fShmNonRtServerControl.writeUInt(messageSize);

  1518.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1519.             fShmNonRtServerControl.commitWrite();

  1520.         }

  1521.     }

  1522. 

  1523.     // called from process thread above

  1524.     EngineEvent* getNextFreeInputEvent() const noexcept

  1525.     {

  1526.         for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)

  1527.         {

  1528.             EngineEvent* const event(&pData->events.in[i]);

  1529. 

  1530.             if (event->type == kEngineEventTypeNull)

  1531.                 return event;

  1532.         }

  1533.         return nullptr;

  1534.     }

  1535. 

  1536.     void latencyChanged(const uint32_t samples) noexcept override

  1537.     {

  1538.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1539. 

  1540.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1541.         fShmNonRtServerControl.writeUInt(samples);

  1542.         fShmNonRtServerControl.commitWrite();

  1543.     }

  1544. 

  1545.     // -------------------------------------------------------------------

  1546. 

  1547. private:

  1548.     BridgeAudioPool          fShmAudioPool;

  1549.     BridgeRtClientControl    fShmRtClientControl;

  1550.     BridgeNonRtClientControl fShmNonRtClientControl;

  1551.     BridgeNonRtServerControl fShmNonRtServerControl;

  1552. 

  1553.     CarlaString fBaseNameAudioPool;

  1554.     CarlaString fBaseNameRtClientControl;

  1555.     CarlaString fBaseNameNonRtClientControl;

  1556.     CarlaString fBaseNameNonRtServerControl;

  1557. 

  1558.     bool fClosingDown;

  1559.     bool fIsOffline;

  1560.     bool fFirstIdle;

  1561.     int64_t fLastPingTime;

  1562. 

  1563.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1564. };

  1565. 

  1566. // -----------------------------------------------------------------------

  1567. 

  1568. namespace EngineInit {

  1569. 

  1570. CarlaEngine* newBridge(const char* const audioPoolBaseName,

  1571.                        const char* const rtClientBaseName,

  1572.                        const char* const nonRtClientBaseName,

  1573.                        const char* const nonRtServerBaseName)

  1574. {

  1575.     return new CarlaEngineBridge(audioPoolBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);

  1576. }

  1577. 

  1578. }

  1579. 

  1580. // -----------------------------------------------------------------------

  1581. 

  1582. CARLA_BACKEND_END_NAMESPACE

  1583. 

  1584. // -----------------------------------------------------------------------

  1585. 

  1586. #include "CarlaBridgeUtils.cpp"

  1587. 

  1588. // -----------------------------------------------------------------------