falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
7009 Commits
17 Branches
1.0GB
Tree: da31486cb6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'da31486cb6'
${ noResults }
Carla/source/backend/engine/CarlaEngineBridge.cpp

1706 lines
67KB
Raw Blame History 

  1. // SPDX-FileCopyrightText: 2011-2025 Filipe Coelho <falktx@falktx.com>

  2. // SPDX-License-Identifier: GPL-2.0-or-later

  3. 

  4. #ifndef BUILD_BRIDGE

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

  6. #endif

  7. 

  8. // must be first so we can undef CARLA_SAFE_*_RETURN_ERR* macros

  9. #include "CarlaPluginInternal.hpp"

  10. #undef CARLA_SAFE_ASSERT_RETURN_ERR

  11. #undef CARLA_SAFE_ASSERT_RETURN_ERRN

  12. #undef CARLA_SAFE_EXCEPTION_RETURN_ERR

  13. #undef CARLA_SAFE_EXCEPTION_RETURN_ERRN

  14. 

  15. #include "CarlaEngineClient.hpp"

  16. #include "CarlaEngineInit.hpp"

  17. 

  18. #include "CarlaBackendUtils.hpp"

  19. #include "CarlaBridgeUtils.hpp"

  20. #include "CarlaMIDI.h"

  21. 

  22. #ifdef __SSE2_MATH__

  23. # include <xmmintrin.h>

  24. #endif

  25. 

  26. #include "distrho/extra/Base64.hpp"

  27. #include "distrho/extra/Time.hpp"

  28. 

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

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

  31. 

  32. // must be last

  33. #include "jackbridge/JackBridge.hpp"

  34. 

  35. using water::File;

  36. using water::MemoryBlock;

  37. using water::String;

  38. 

  39. CARLA_BACKEND_START_NAMESPACE

  40. 

  41. // -----------------------------------------------------------------------

  42. // Bridge Engine client

  43. 

  44. struct LatencyChangedCallback {

  45.     virtual ~LatencyChangedCallback() noexcept {}

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

  47. };

  48. 

  49. class CarlaEngineBridgeClient : public CarlaEngineClientForSubclassing

  50. {

  51. public:

  52. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  53.     CarlaEngineBridgeClient(const CarlaEngine& engine,

  54.                             EngineInternalGraph& egraph,

  55.                             const CarlaPluginPtr plugin,

  56.                             LatencyChangedCallback* const cb)

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

  58.           fLatencyCallback(cb) {}

  59. #else

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

  61.         : CarlaEngineClientForSubclassing(engine),

  62.           fLatencyCallback(cb) {}

  63. #endif

  64. 

  65. protected:

  66.     void setLatency(const uint32_t samples) noexcept override

  67.     {

  68.         if (getLatency() == samples)

  69.             return;

  70. 

  71.         fLatencyCallback->latencyChanged(samples);

  72.         CarlaEngineClient::setLatency(samples);

  73.     }

  74. 

  75. private:

  76.     LatencyChangedCallback* const fLatencyCallback;

  77. 

  78.     CARLA_DECLARE_NON_COPYABLE(CarlaEngineBridgeClient)

  79. };

  80. 

  81. // -------------------------------------------------------------------

  82. 

  83. struct BridgeTextReader {

  84.     char* text;

  85. 

  86.     BridgeTextReader(BridgeNonRtClientControl& nonRtClientCtrl)

  87.         : text(nullptr)

  88.     {

  89.         const uint32_t size = nonRtClientCtrl.readUInt();

  90.         CARLA_SAFE_ASSERT_RETURN(size != 0,);

  91. 

  92.         text = new char[size + 1];

  93.         nonRtClientCtrl.readCustomData(text, size);

  94.         text[size] = '\0';

  95.     }

  96. 

  97.     BridgeTextReader(BridgeNonRtClientControl& nonRtClientCtrl, const uint32_t size)

  98.         : text(nullptr)

  99.     {

  100.         text = new char[size + 1];

  101. 

  102.         if (size != 0)

  103.             nonRtClientCtrl.readCustomData(text, size);

  104. 

  105.         text[size] = '\0';

  106.     }

  107. 

  108.     ~BridgeTextReader() noexcept

  109.     {

  110.         delete[] text;

  111.     }

  112. 

  113.     CARLA_DECLARE_NON_COPYABLE(BridgeTextReader)

  114. };

  115. 

  116. // -------------------------------------------------------------------

  117. 

  118. class CarlaEngineBridge : public CarlaEngine,

  119.                           private CarlaThread,

  120.                           private LatencyChangedCallback

  121. {

  122. public:

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

  124.         : CarlaEngine(),

  125.           CarlaThread("CarlaEngineBridge"),

  126.           fShmAudioPool(),

  127.           fShmRtClientControl(),

  128.           fShmNonRtClientControl(),

  129.           fShmNonRtServerControl(),

  130.           fBaseNameAudioPool(audioPoolBaseName),

  131.           fBaseNameRtClientControl(rtClientBaseName),

  132.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  133.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  134.           fClosingDown(false),

  135.           fIsOffline(false),

  136.           fFirstIdle(true),

  137.           fBridgeVersion(0),

  138.           fLastPingTime(UINT32_MAX)

  139.     {

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

  141.     }

  142. 

  143.     ~CarlaEngineBridge() noexcept override

  144.     {

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

  146. 

  147.         clear();

  148.     }

  149. 

  150.     // -------------------------------------

  151.     // CarlaEngine virtual calls

  152. 

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

  154.     {

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

  156. 

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

  158.         {

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

  160.             return false;

  161.         }

  162. 

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

  164.         {

  165.             pData->close();

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

  167.             return false;

  168.         }

  169. 

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

  171.         {

  172.             pData->close();

  173.             clear();

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

  175.             return false;

  176.         }

  177. 

  178.         if (! fShmRtClientControl.mapData())

  179.         {

  180.             pData->close();

  181.             clear();

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

  183.             return false;

  184.         }

  185. 

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

  187.         {

  188.             pData->close();

  189.             clear();

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

  191.             return false;

  192.         }

  193. 

  194.         if (! fShmNonRtClientControl.mapData())

  195.         {

  196.             pData->close();

  197.             clear();

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

  199.             return false;

  200.         }

  201. 

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

  203.         {

  204.             pData->close();

  205.             clear();

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

  207.             return false;

  208.         }

  209. 

  210.         if (! fShmNonRtServerControl.mapData())

  211.         {

  212.             pData->close();

  213.             clear();

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

  215.             return false;

  216.         }

  217. 

  218.         PluginBridgeNonRtClientOpcode opcode;

  219. 

  220.         opcode = fShmNonRtClientControl.readOpcode();

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

  222. 

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

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

  225. 

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

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

  228. 

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

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

  231. 

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

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

  234. 

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

  236.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  237.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  238.         {

  239.             pData->close();

  240.             clear();

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

  242.             return false;

  243.         }

  244. 

  245.         opcode = fShmNonRtClientControl.readOpcode();

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

  247. 

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

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

  250. 

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

  252.         {

  253.             pData->close();

  254.             clear();

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

  256.             return false;

  257.         }

  258. 

  259.         pData->initTime(nullptr);

  260. 

  261.         // tell backend we're live

  262.         {

  263.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  264. 

  265.             // kPluginBridgeNonRtServerVersion was added in API 7

  266.             if (apiVersion >= 7)

  267.             {

  268.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  269.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  270.             }

  271.             else

  272.             {

  273.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  274.             }

  275. 

  276.             fShmNonRtServerControl.commitWrite();

  277.         }

  278. 

  279.         startThread(true);

  280.         return true;

  281.     }

  282. 

  283.     bool close() override

  284.     {

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

  286.         fLastPingTime = UINT32_MAX;

  287. 

  288.         CarlaEngine::close();

  289. 

  290.         stopThread(5000);

  291.         clear();

  292. 

  293.         return true;

  294.     }

  295. 

  296.     bool hasIdleOnMainThread() const noexcept override

  297.     {

  298.         return true;

  299.     }

  300. 

  301.     bool isRunning() const noexcept override

  302.     {

  303.         if (fClosingDown)

  304.             return false;

  305. 

  306.         return isThreadRunning() || ! fFirstIdle;

  307.     }

  308. 

  309.     bool isOffline() const noexcept override

  310.     {

  311.         return fIsOffline;

  312.     }

  313. 

  314.     EngineType getType() const noexcept override

  315.     {

  316.         return kEngineTypeBridge;

  317.     }

  318. 

  319.     const char* getCurrentDriverName() const noexcept override

  320.     {

  321.         return "Bridge";

  322.     }

  323. 

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

  325.     {

  326.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  327. 

  328.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  329.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  330.         fShmNonRtServerControl.writeUInt(parameterId);

  331.         fShmNonRtServerControl.writeBool(touch);

  332.         fShmNonRtServerControl.commitWrite();

  333.     }

  334. 

  335.     CarlaEngineClient* addClient(const CarlaPluginPtr plugin) override

  336.     {

  337. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  339. #else

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

  341. 

  342.         // unused

  343.         (void)plugin;

  344. #endif

  345.     }

  346. 

  347.     void idle() noexcept override

  348.     {

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

  350. 

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

  352.         {

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

  354.             {

  355.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  356.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  357.                 fShmNonRtServerControl.writeUInt(length);

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

  359.                 fShmNonRtServerControl.commitWrite();

  360.             }

  361. 

  362.             signalThreadShouldExit();

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

  364.             return;

  365.         }

  366. 

  367.         const bool wasFirstIdle = fFirstIdle;

  368. 

  369.         if (wasFirstIdle)

  370.         {

  371.             fFirstIdle = false;

  372.             fLastPingTime = d_gettime_ms();

  373. 

  374.             char bufStr[STR_MAX+1];

  375.             carla_zeroChars(bufStr, STR_MAX+1);

  376. 

  377.             uint32_t bufStrSize;

  378. 

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

  380.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  381. 

  382.             // kPluginBridgeNonRtServerPluginInfo1

  383.             {

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

  385.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  391.                 fShmNonRtServerControl.commitWrite();

  392.             }

  393. 

  394.             // kPluginBridgeNonRtServerPluginInfo2

  395.             {

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

  397.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  398. 

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

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

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

  402.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  403.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  404. 

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

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

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

  408.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  409.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  410. 

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

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

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

  414.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  415.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  416. 

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

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

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

  420.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  421.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  422. 

  423.                 fShmNonRtServerControl.commitWrite();

  424.             }

  425. 

  426.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  427. 

  428.             // kPluginBridgeNonRtServerAudioCount

  429.             {

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

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

  432. 

  433.                 // uint/ins, uint/outs

  434.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  435.                 fShmNonRtServerControl.writeUInt(aIns);

  436.                 fShmNonRtServerControl.writeUInt(aOuts);

  437.                 fShmNonRtServerControl.commitWrite();

  438. 

  439.                 // kPluginBridgeNonRtServerPortName

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

  441.                 {

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

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

  444. 

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

  446.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  447.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  448.                     fShmNonRtServerControl.writeUInt(i);

  449. 

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

  451.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  452.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  453.                 }

  454. 

  455.                 // kPluginBridgeNonRtServerPortName

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

  457.                 {

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

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

  460. 

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

  462.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  463.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  464.                     fShmNonRtServerControl.writeUInt(i);

  465. 

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

  467.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  468.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  469.                 }

  470.             }

  471. 

  472.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  473. 

  474.             // kPluginBridgeNonRtServerMidiCount

  475.             {

  476.                 // uint/ins, uint/outs

  477.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  480.                 fShmNonRtServerControl.commitWrite();

  481.             }

  482. 

  483.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  484. 

  485.             // kPluginBridgeNonRtServerCvCount

  486.             {

  487.                 // uint/ins, uint/outs

  488.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  491.                 fShmNonRtServerControl.commitWrite();

  492.             }

  493. 

  494.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  495. 

  496.             // kPluginBridgeNonRtServerParameter*

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

  498.             {

  499.                 // uint/count

  500.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  501.                 fShmNonRtServerControl.writeUInt(count);

  502.                 fShmNonRtServerControl.commitWrite();

  503. 

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

  505.                 {

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

  507. 

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

  509.                         continue;

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

  511.                         continue;

  512. 

  513.                     // kPluginBridgeNonRtServerParameterData1

  514.                     {

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

  516.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  517.                         fShmNonRtServerControl.writeUInt(i);

  518.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  519.                         fShmNonRtServerControl.writeUInt(paramData.type);

  520.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  521.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  522.                         fShmNonRtServerControl.commitWrite();

  523.                     }

  524. 

  525.                     // kPluginBridgeNonRtServerParameterData2

  526.                     {

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

  528.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  529.                         fShmNonRtServerControl.writeUInt(i);

  530. 

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

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

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

  534.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  535.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  536. 

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

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

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

  540.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  541.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  542. 

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

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

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

  546.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  547.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  548. 

  549.                         fShmNonRtServerControl.commitWrite();

  550.                     }

  551. 

  552.                     // kPluginBridgeNonRtServerParameterRanges

  553.                     {

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

  555. 

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

  557.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  558.                         fShmNonRtServerControl.writeUInt(i);

  559.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  560.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  561.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  562.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  563.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  564.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  565.                         fShmNonRtServerControl.commitWrite();

  566.                     }

  567. 

  568.                     // kPluginBridgeNonRtServerParameterValue2

  569.                     {

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

  571.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  572.                         fShmNonRtServerControl.writeUInt(i);

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

  574.                         fShmNonRtServerControl.commitWrite();

  575.                     }

  576. 

  577.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  578.                 }

  579.             }

  580. 

  581.             // kPluginBridgeNonRtServerProgram*

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

  583.             {

  584.                 // uint/count

  585.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  586.                 fShmNonRtServerControl.writeUInt(count);

  587.                 fShmNonRtServerControl.commitWrite();

  588. 

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

  590.                 {

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

  592.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  593.                     fShmNonRtServerControl.writeUInt(i);

  594. 

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

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

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

  598.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  599.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  600. 

  601.                     fShmNonRtServerControl.commitWrite();

  602.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  603.                 }

  604.             }

  605. 

  606.             // kPluginBridgeNonRtServerMidiProgram*

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

  608.             {

  609.                 // uint/count

  610.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  611.                 fShmNonRtServerControl.writeUInt(count);

  612.                 fShmNonRtServerControl.commitWrite();

  613. 

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

  615.                 {

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

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

  618. 

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

  620.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  621.                     fShmNonRtServerControl.writeUInt(i);

  622.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  623.                     fShmNonRtServerControl.writeUInt(mpData.program);

  624. 

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

  626.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  628. 

  629.                     fShmNonRtServerControl.commitWrite();

  630.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  631.                 }

  632.             }

  633. 

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

  635.             {

  636.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  637.                 fShmNonRtServerControl.writeUInt(latency);

  638.                 fShmNonRtServerControl.commitWrite();

  639.             }

  640. 

  641.             // ready!

  642.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  643.             fShmNonRtServerControl.commitWrite();

  644.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  645. 

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

  647.             fLastPingTime = d_gettime_ms();

  648.         }

  649. 

  650.         // send parameter outputs

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

  652.         {

  653.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  654. 

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

  656.             {

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

  658.                     continue;

  659. 

  660.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  661.                 fShmNonRtServerControl.writeUInt(i);

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

  663. 

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

  665.                 if (! fShmNonRtServerControl.commitWrite())

  666.                     break;

  667.             }

  668.         }

  669. 

  670.         CarlaEngine::idle();

  671. 

  672.         try {

  673.             handleNonRtData();

  674.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  675. 

  676.         if (fLastPingTime != UINT32_MAX && d_gettime_ms() > fLastPingTime + 30000 && ! wasFirstIdle)

  677.         {

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

  679.             signalThreadShouldExit();

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

  681.         }

  682.     }

  683. 

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

  685.                   const EngineCallbackOpcode action, const uint pluginId,

  686.                   const int value1, const int value2, const int value3,

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

  688.     {

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

  690. 

  691.         if (fClosingDown || ! sendHost)

  692.             return;

  693. 

  694.         switch (action)

  695.         {

  696.         // uint/index float/value

  697.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  698.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  699.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  700.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  702.             fShmNonRtServerControl.writeFloat(valuef);

  703.             fShmNonRtServerControl.commitWrite();

  704.         }   break;

  705. 

  706.         // uint/index float/value

  707.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  708.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  709.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  710.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  712.             fShmNonRtServerControl.writeFloat(valuef);

  713.             fShmNonRtServerControl.commitWrite();

  714.         }   break;

  715. 

  716.         // int/index

  717.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  718.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  719.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  720.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  721.             fShmNonRtServerControl.writeInt(value1);

  722.             fShmNonRtServerControl.commitWrite();

  723.         }   break;

  724. 

  725.         // int/index

  726.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  727.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  728.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  729.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  730.             fShmNonRtServerControl.writeInt(value1);

  731.             fShmNonRtServerControl.commitWrite();

  732.         }   break;

  733. 

  734.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  735.             if (value1 != 1)

  736.             {

  737.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  738.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  739.                 fShmNonRtServerControl.commitWrite();

  740.             }

  741.             break;

  742. 

  743.         case ENGINE_CALLBACK_EMBED_UI_RESIZED: {

  744.             CARLA_SAFE_ASSERT_BREAK(value1 > 1);

  745.             CARLA_SAFE_ASSERT_BREAK(value2 > 1);

  746. 

  747.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  748. 

  749.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerResizeEmbedUI);

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

  751.             fShmNonRtServerControl.writeUInt(static_cast<uint>(value2));

  752.             fShmNonRtServerControl.commitWrite();

  753.         }   break;

  754. 

  755.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

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

  757.             {

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

  759.                 {

  760.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  761. 

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

  763.                     {

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

  765. 

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

  767.                             continue;

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

  769.                             continue;

  770. 

  771.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  772.                         fShmNonRtServerControl.writeUInt(i);

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

  774.                         fShmNonRtServerControl.commitWrite();

  775. 

  776.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  777.                     }

  778.                 }

  779.             }

  780.             break;

  781. 

  782.         default:

  783.             break;

  784.         }

  785.     }

  786. 

  787.     // -------------------------------------------------------------------

  788. 

  789.     void clear() noexcept

  790.     {

  791.         fShmAudioPool.clear();

  792.         fShmRtClientControl.clear();

  793.         fShmNonRtClientControl.clear();

  794.         fShmNonRtServerControl.clear();

  795.     }

  796. 

  797.     void handleNonRtData()

  798.     {

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

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

  801. 

  802.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  803.         {

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

  805. 

  806. #ifdef DEBUG

  807.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  809.                             opcode, PluginBridgeNonRtClientOpcode2str(opcode));

  810.             }

  811. #endif

  812. 

  813.             if (opcode != kPluginBridgeNonRtClientNull &&

  814.                 opcode != kPluginBridgeNonRtClientPingOnOff && fLastPingTime != UINT32_MAX)

  815.                 fLastPingTime = d_gettime_ms();

  816. 

  817.             switch (opcode)

  818.             {

  819.             case kPluginBridgeNonRtClientNull:

  820.                 break;

  821. 

  822.             case kPluginBridgeNonRtClientVersion: {

  823.                 fBridgeVersion = fShmNonRtServerControl.readUInt();

  824.                 CARLA_SAFE_ASSERT_UINT2(fBridgeVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  825.                                         fBridgeVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  826.             }   break;

  827. 

  828.             case kPluginBridgeNonRtClientPing: {

  829.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  830. 

  831.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  832.                 fShmNonRtServerControl.commitWrite();

  833.             }   break;

  834. 

  835.             case kPluginBridgeNonRtClientPingOnOff:

  836.                 fLastPingTime = fShmNonRtClientControl.readBool() ? d_gettime_ms() : UINT32_MAX;

  837.                 break;

  838. 

  839.             case kPluginBridgeNonRtClientActivate:

  840.                 if (plugin->isEnabled())

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

  842.                 break;

  843. 

  844.             case kPluginBridgeNonRtClientDeactivate:

  845.                 if (plugin->isEnabled())

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

  847.                 break;

  848. 

  849.             case kPluginBridgeNonRtClientInitialSetup:

  850.                 // should never happen!!

  851.                 fShmNonRtServerControl.readUInt();

  852.                 fShmNonRtServerControl.readDouble();

  853.                 break;

  854. 

  855.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  858. 

  859.                 if (plugin->isEnabled())

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

  861.                 break;

  862.             }

  863. 

  864.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  867. 

  868.                 if (plugin->isEnabled())

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

  870.                 break;

  871.             }

  872. 

  873.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

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

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

  876. 

  877.                 if (plugin->isEnabled())

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

  879.                 break;

  880.             }

  881. 

  882.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  886. 

  887.                 if (plugin->isEnabled())

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

  889.                 break;

  890.             }

  891. 

  892.             case kPluginBridgeNonRtClientSetProgram: {

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

  894. 

  895.                 if (plugin->isEnabled())

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

  897.                 break;

  898.             }

  899. 

  900.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  902. 

  903.                 if (plugin->isEnabled())

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

  905.                 break;

  906.             }

  907. 

  908.             case kPluginBridgeNonRtClientSetCustomData: {

  909.                 const uint32_t maxLocalValueLen = fBridgeVersion >= 10 ? 4096 : 16384;

  910. 

  911.                 // type

  912.                 const BridgeTextReader type(fShmNonRtClientControl);

  913. 

  914.                 // key

  915.                 const BridgeTextReader key(fShmNonRtClientControl);

  916. 

  917.                 // value

  918.                 const uint32_t valueSize = fShmNonRtClientControl.readUInt();

  919. 

  920.                 if (valueSize > 0)

  921.                 {

  922.                     if (valueSize > maxLocalValueLen)

  923.                     {

  924.                         const BridgeTextReader bigValueFilePathTry(fShmNonRtClientControl);

  925. 

  926.                         CARLA_SAFE_ASSERT_BREAK(bigValueFilePathTry.text[0] != '\0');

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

  928. 

  929.                         String bigValueFilePath(bigValueFilePathTry.text);

  930. 

  931. #ifdef CARLA_OS_WIN

  932.                         // check if running under Wine

  933.                         if (bigValueFilePath.startsWith("/"))

  934.                             bigValueFilePath = bigValueFilePath.replaceSection(0, 1, "Z:\\").replace("/", "\\");

  935. #endif

  936. 

  937.                         File bigValueFile(bigValueFilePath.toRawUTF8());

  938.                         CARLA_SAFE_ASSERT_BREAK(bigValueFile.existsAsFile());

  939. 

  940.                         plugin->setCustomData(type.text, key.text, bigValueFile.loadFileAsString().toRawUTF8(), true);

  941. 

  942.                         bigValueFile.deleteFile();

  943.                     }

  944.                     else

  945.                     {

  946.                         const BridgeTextReader value(fShmNonRtClientControl, valueSize);

  947. 

  948.                         if (plugin->isEnabled())

  949.                             plugin->setCustomData(type.text, key.text, value.text, true);

  950.                     }

  951.                 }

  952.                 else

  953.                 {

  954.                     if (plugin->isEnabled())

  955.                         plugin->setCustomData(type.text, key.text, "", true);

  956.                 }

  957. 

  958.                 break;

  959.             }

  960. 

  961.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  963.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  964. 

  965.                 const BridgeTextReader chunkFilePathTry(fShmNonRtClientControl, size);

  966. 

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

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

  969. 

  970.                 String chunkFilePath(chunkFilePathTry.text);

  971. 

  972. #ifdef CARLA_OS_WIN

  973.                 // check if running under Wine

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

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

  976. #endif

  977. 

  978.                 File chunkFile(chunkFilePath.toRawUTF8());

  979.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  980. 

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

  982.                 chunkFile.deleteFile();

  983.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  984. 

  985.                 std::vector<uint8_t> chunk;

  986.                 d_getChunkFromBase64String_impl(chunk, chunkDataBase64.toRawUTF8());

  987. 

  988. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  990. #else

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

  992. #endif

  993.                 break;

  994.             }

  995. 

  996.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  999. 

  1000.                 if (plugin->isEnabled())

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

  1002.                 break;

  1003.             }

  1004. 

  1005.             case kPluginBridgeNonRtClientSetOption: {

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

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

  1008. 

  1009.                 if (plugin->isEnabled())

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

  1011.                 break;

  1012.             }

  1013. 

  1014.             case kPluginBridgeNonRtClientSetOptions: {

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

  1016. 

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

  1018.                 break;

  1019.             }

  1020. 

  1021.             case kPluginBridgeNonRtClientSetWindowTitle: {

  1022.                 const BridgeTextReader title(fShmNonRtClientControl);

  1023. 

  1024.                 plugin->setCustomUITitle(title.text);

  1025.                 break;

  1026.             }

  1027. 

  1028.             case kPluginBridgeNonRtClientGetParameterText: {

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

  1030. 

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

  1032.                 {

  1033.                     char bufStr[STR_MAX+1];

  1034.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  1037. 

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

  1039. 

  1040.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1041. 

  1042.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1043. 

  1044.                     fShmNonRtServerControl.writeInt(index);

  1045.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  1046.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  1047.                     fShmNonRtServerControl.commitWrite();

  1048. 

  1049.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1050.                 }

  1051.                 else

  1052.                 {

  1053.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1054. 

  1055.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1056.                     fShmNonRtServerControl.writeInt(index);

  1057.                     fShmNonRtServerControl.writeUInt(0);

  1058.                     fShmNonRtServerControl.commitWrite();

  1059.                 }

  1060. 

  1061.                 break;

  1062.             }

  1063. 

  1064.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1066.                 {

  1067.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1068.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1069.                     fShmNonRtServerControl.commitWrite();

  1070.                     return;

  1071.                 }

  1072. 

  1073.                 plugin->prepareForSave(false);

  1074. 

  1075.                 const uint32_t maxLocalValueLen = fBridgeVersion >= 10 ? 4096 : 16384;

  1076. 

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

  1078.                 {

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

  1080. 

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

  1082.                         continue;

  1083. 

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

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

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

  1087. 

  1088.                     {

  1089.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1090. 

  1091.                         if (valueLen > maxLocalValueLen)

  1092.                             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1093. 

  1094.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1095. 

  1096.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1098. 

  1099.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1101. 

  1102.                         fShmNonRtServerControl.writeUInt(valueLen);

  1103. 

  1104.                         if (valueLen > 0)

  1105.                         {

  1106.                             if (valueLen > maxLocalValueLen)

  1107.                             {

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

  1109. 

  1110.                                 filePath += CARLA_OS_SEP_STR ".CarlaCustomData_";

  1111.                                 filePath += fShmAudioPool.getFilenameSuffix();

  1112. 

  1113.                                 if (File(filePath.toRawUTF8()).replaceWithText(cdata.value))

  1114.                                 {

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

  1116. 

  1117.                                     fShmNonRtServerControl.writeUInt(ulength);

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

  1119.                                 }

  1120.                                 else

  1121.                                 {

  1122.                                     fShmNonRtServerControl.writeUInt(0);

  1123.                                 }

  1124.                             }

  1125.                             else

  1126.                             {

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

  1128.                             }

  1129.                         }

  1130. 

  1131.                         fShmNonRtServerControl.commitWrite();

  1132.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1133.                     }

  1134.                 }

  1135. 

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

  1137.                 {

  1138.                     void* data = nullptr;

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

  1140.                     {

  1141.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1142. 

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

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

  1145. 

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

  1147. 

  1148.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1149.                         filePath += fShmAudioPool.getFilenameSuffix();

  1150. 

  1151.                         if (File(filePath.toRawUTF8()).replaceWithText(dataBase64.buffer()))

  1152.                         {

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

  1154. 

  1155.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1156. 

  1157.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1158.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1160.                             fShmNonRtServerControl.commitWrite();

  1161.                         }

  1162.                     }

  1163.                 }

  1164. 

  1165.                 {

  1166.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1167. 

  1168.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1169.                     fShmNonRtServerControl.commitWrite();

  1170.                 }

  1171.                 break;

  1172.             }

  1173. 

  1174.             case kPluginBridgeNonRtClientRestoreLV2State:

  1175.                 if (plugin->isEnabled())

  1176.                     plugin->restoreLV2State(false);

  1177.                 break;

  1178. 

  1179.             case kPluginBridgeNonRtClientShowUI:

  1180.                 if (plugin->isEnabled())

  1181.                     plugin->showCustomUI(true);

  1182.                 break;

  1183. 

  1184.             case kPluginBridgeNonRtClientHideUI:

  1185.                 if (plugin->isEnabled())

  1186.                     plugin->showCustomUI(false);

  1187.                 break;

  1188. 

  1189.             case kPluginBridgeNonRtClientEmbedUI: {

  1190.                 const uint64_t winId = fShmNonRtClientControl.readULong();

  1191.                 uint64_t resp = 0;

  1192. 

  1193.                 if (plugin->isEnabled())

  1194.                     resp = reinterpret_cast<uint64_t>(plugin->embedCustomUI(reinterpret_cast<void*>(winId)));

  1195. 

  1196.                 if (resp == 0)

  1197.                     resp = 1;

  1198. 

  1199.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1200. 

  1201.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerRespEmbedUI);

  1202.                 fShmNonRtServerControl.writeULong(resp);

  1203.                 fShmNonRtServerControl.commitWrite();

  1204.                 break;

  1205.             }

  1206. 

  1207.             case kPluginBridgeNonRtClientUiParameterChange: {

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

  1209.                 const float    value = fShmNonRtClientControl.readFloat();

  1210. 

  1211.                 if (plugin->isEnabled())

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

  1213.                 break;

  1214.             }

  1215. 

  1216.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1218. 

  1219.                 if (plugin->isEnabled())

  1220.                     plugin->uiProgramChange(index);

  1221.                 break;

  1222.             }

  1223. 

  1224.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1226. 

  1227.                 if (plugin->isEnabled())

  1228.                     plugin->uiMidiProgramChange(index);

  1229.                 break;

  1230.             }

  1231. 

  1232.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1236. 

  1237.                 if (plugin->isEnabled())

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

  1239.                 break;

  1240.             }

  1241. 

  1242.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1245. 

  1246.                 if (plugin->isEnabled())

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

  1248.                 break;

  1249.             }

  1250. 

  1251.             case kPluginBridgeNonRtClientQuit:

  1252.                 fClosingDown = true;

  1253.                 signalThreadShouldExit();

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

  1255.                 break;

  1256. 

  1257.             case kPluginBridgeNonRtClientReload:

  1258.                 fFirstIdle = true;

  1259.                 break;

  1260.             }

  1261.         }

  1262.     }

  1263. 

  1264.     // -------------------------------------------------------------------

  1265. 

  1266. protected:

  1267.     void run() override

  1268.     {

  1269. #ifdef __SSE2_MATH__

  1270.         // Set FTZ and DAZ flags

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

  1272. #endif

  1273. 

  1274.         bool quitReceived = false;

  1275. 

  1276.         for (; ! shouldThreadExit();)

  1277.         {

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

  1279. 

  1280.             if (! helper.ok)

  1281.                 continue;

  1282. 

  1283.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1284.             {

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

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

  1287. 

  1288. #ifdef DEBUG

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

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

  1291.                 }

  1292. #endif

  1293. 

  1294.                 switch (opcode)

  1295.                 {

  1296.                 case kPluginBridgeRtClientNull:

  1297.                     break;

  1298. 

  1299.                 case kPluginBridgeRtClientSetAudioPool: {

  1300.                     if (fShmAudioPool.data != nullptr)

  1301.                     {

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

  1303.                         fShmAudioPool.data = nullptr;

  1304.                     }

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

  1306.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1308.                     break;

  1309.                 }

  1310. 

  1311.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1313.                     pData->bufferSize = bufferSize;

  1314.                     bufferSizeChanged(bufferSize);

  1315.                     break;

  1316.                 }

  1317. 

  1318.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1320.                     pData->sampleRate = sampleRate;

  1321.                     sampleRateChanged(sampleRate);

  1322.                     break;

  1323.                 }

  1324. 

  1325.                 case kPluginBridgeRtClientSetOnline:

  1326.                     fIsOffline = fShmRtClientControl.readBool();

  1327.                     offlineModeChanged(fIsOffline);

  1328.                     break;

  1329. 

  1330.                 // NOTE this is never used

  1331.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1336. 

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

  1338.                     {

  1339.                         event->type                 = kEngineEventTypeControl;

  1340.                         event->time                 = time;

  1341.                         event->channel              = channel;

  1342.                         event->ctrl.type            = kEngineControlEventTypeParameter;

  1343.                         event->ctrl.param           = param;

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

  1345.                         event->ctrl.normalizedValue = value;

  1346.                         event->ctrl.handled         = true;

  1347.                     }

  1348.                     break;

  1349.                 }

  1350. 

  1351.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1355. 

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

  1357.                     {

  1358.                         event->type                 = kEngineEventTypeControl;

  1359.                         event->time                 = time;

  1360.                         event->channel              = channel;

  1361.                         event->ctrl.type            = kEngineControlEventTypeMidiBank;

  1362.                         event->ctrl.param           = index;

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

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

  1365.                         event->ctrl.handled         = true;

  1366.                     }

  1367.                     break;

  1368.                 }

  1369. 

  1370.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1374. 

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

  1376.                     {

  1377.                         event->type                 = kEngineEventTypeControl;

  1378.                         event->time                 = time;

  1379.                         event->channel              = channel;

  1380.                         event->ctrl.type            = kEngineControlEventTypeMidiProgram;

  1381.                         event->ctrl.param           = index;

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

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

  1384.                         event->ctrl.handled         = true;

  1385.                     }

  1386.                     break;

  1387.                 }

  1388. 

  1389.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1392. 

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

  1394.                     {

  1395.                         event->type                 = kEngineEventTypeControl;

  1396.                         event->time                 = time;

  1397.                         event->channel              = channel;

  1398.                         event->ctrl.type            = kEngineControlEventTypeAllSoundOff;

  1399.                         event->ctrl.param           = 0;

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

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

  1402.                         event->ctrl.handled         = true;

  1403.                     }

  1404.                 }   break;

  1405. 

  1406.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1409. 

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

  1411.                     {

  1412.                         event->type                 = kEngineEventTypeControl;

  1413.                         event->time                 = time;

  1414.                         event->channel              = channel;

  1415.                         event->ctrl.type            = kEngineControlEventTypeAllNotesOff;

  1416.                         event->ctrl.param           = 0;

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

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

  1419.                         event->ctrl.handled         = true;

  1420.                     }

  1421.                 }   break;

  1422. 

  1423.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1427.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1428. 

  1429.                     // FIXME variable-size stack

  1430.                     uint8_t data[4];

  1431. 

  1432.                     {

  1433.                         uint8_t i=0;

  1434.                         for (; i<size && i<4; ++i)

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

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

  1437.                             fShmRtClientControl.readByte();

  1438.                     }

  1439. 

  1440.                     if (size > 4)

  1441.                         continue;

  1442. 

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

  1444.                     {

  1445.                         event->type    = kEngineEventTypeMidi;

  1446.                         event->time    = time;

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

  1448. 

  1449.                         event->midi.port = port;

  1450.                         event->midi.size = size;

  1451. 

  1452.                         if (size > EngineMidiEvent::kDataSize)

  1453.                         {

  1454.                             event->midi.dataExt = data;

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

  1456.                         }

  1457.                         else

  1458.                         {

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

  1460. 

  1461.                             uint8_t i=1;

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

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

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

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

  1466. 

  1467.                             event->midi.dataExt = nullptr;

  1468.                         }

  1469.                     }

  1470.                     break;

  1471.                 }

  1472. 

  1473.                 case kPluginBridgeRtClientProcess: {

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

  1475. 

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

  1477. 

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

  1479.                     {

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

  1481. 

  1482.                         const uint32_t audioInCount = plugin->getAudioInCount();

  1483.                         const uint32_t audioOutCount = plugin->getAudioOutCount();

  1484.                         const uint32_t cvInCount = plugin->getCVInCount();

  1485.                         const uint32_t cvOutCount = plugin->getCVOutCount();

  1486. 

  1487.                         const float* audioIn[64];

  1488.                         /* */ float* audioOut[64];

  1489.                         const float* cvIn[32];

  1490.                         /* */ float* cvOut[32];

  1491. 

  1492.                         float* fdata = fShmAudioPool.data;

  1493. 

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

  1495.                             audioIn[i] = fdata;

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

  1497.                             audioOut[i] = fdata;

  1498. 

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

  1500.                             cvIn[i] = fdata;

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

  1502.                             cvOut[i] = fdata;

  1503. 

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

  1505. 

  1506.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1507.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1508.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1510. 

  1511.                         if (timeInfo.bbt.valid)

  1512.                         {

  1513.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1514.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1515.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1516. 

  1517.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1518.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1519. 

  1520.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1521.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1522.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1523.                         }

  1524. 

  1525.                         plugin->initBuffers();

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

  1527.                         plugin->unlock();

  1528.                     }

  1529. 

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

  1531.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1532.                     std::size_t curMidiDataPos = 0;

  1533. 

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

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

  1536. 

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

  1538.                     {

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

  1540.                         {

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

  1542. 

  1543.                             if (event.type == kEngineEventTypeNull)

  1544.                                 break;

  1545. 

  1546.                             if (event.type == kEngineEventTypeControl)

  1547.                             {

  1548.                                 uint8_t data[3];

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

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

  1551. 

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

  1553.                                     break;

  1554. 

  1555.                                 // set time

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

  1557.                                 midiData = midiData + 4;

  1558.                                 curMidiDataPos += 4;

  1559. 

  1560.                                 // set port

  1561.                                 *midiData++ = 0;

  1562.                                 ++curMidiDataPos;

  1563. 

  1564.                                 // set size

  1565.                                 *midiData++ = size;

  1566.                                 ++curMidiDataPos;

  1567. 

  1568.                                 // set data

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

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

  1571. 

  1572.                                 curMidiDataPos += size;

  1573.                             }

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

  1575.                             {

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

  1577. 

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

  1579.                                     break;

  1580. 

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

  1582. 

  1583.                                 // set time

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

  1585.                                 midiData += 4;

  1586.                                 curMidiDataPos += 4;

  1587. 

  1588.                                 // set port

  1589.                                 *midiData++ = _midiEvent.port;

  1590.                                 ++curMidiDataPos;

  1591. 

  1592.                                 // set size

  1593.                                 *midiData++ = _midiEvent.size;

  1594.                                 ++curMidiDataPos;

  1595. 

  1596.                                 // set data

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

  1598. 

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

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

  1601. 

  1602.                                 curMidiDataPos += _midiEvent.size;

  1603.                             }

  1604.                         }

  1605. 

  1606.                         if (curMidiDataPos != 0 &&

  1607.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1608.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1609. 

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

  1611.                     }

  1612. 

  1613.                 }   break;

  1614. 

  1615.                 case kPluginBridgeRtClientQuit: {

  1616.                     quitReceived = true;

  1617.                     fClosingDown = true;

  1618.                     signalThreadShouldExit();

  1619.                 }   break;

  1620.                 }

  1621.             }

  1622.         }

  1623. 

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

  1625. 

  1626.         if (! quitReceived)

  1627.         {

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

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

  1630. 

  1631.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1632.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1633.             fShmNonRtServerControl.writeUInt(messageSize);

  1634.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1635.             fShmNonRtServerControl.commitWrite();

  1636.         }

  1637.     }

  1638. 

  1639.     // called from process thread above

  1640.     EngineEvent* getNextFreeInputEvent() const noexcept

  1641.     {

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

  1643.         {

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

  1645. 

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

  1647.                 return event;

  1648.         }

  1649.         return nullptr;

  1650.     }

  1651. 

  1652.     void latencyChanged(const uint32_t samples) noexcept override

  1653.     {

  1654.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1655. 

  1656.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1657.         fShmNonRtServerControl.writeUInt(samples);

  1658.         fShmNonRtServerControl.commitWrite();

  1659.     }

  1660. 

  1661.     // -------------------------------------------------------------------

  1662. 

  1663. private:

  1664.     BridgeAudioPool          fShmAudioPool;

  1665.     BridgeRtClientControl    fShmRtClientControl;

  1666.     BridgeNonRtClientControl fShmNonRtClientControl;

  1667.     BridgeNonRtServerControl fShmNonRtServerControl;

  1668. 

  1669.     CarlaString fBaseNameAudioPool;

  1670.     CarlaString fBaseNameRtClientControl;

  1671.     CarlaString fBaseNameNonRtClientControl;

  1672.     CarlaString fBaseNameNonRtServerControl;

  1673. 

  1674.     bool fClosingDown;

  1675.     bool fIsOffline;

  1676.     bool fFirstIdle;

  1677.     uint32_t fBridgeVersion;

  1678.     uint32_t fLastPingTime;

  1679. 

  1680.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1681. };

  1682. 

  1683. // -----------------------------------------------------------------------

  1684. 

  1685. namespace EngineInit {

  1686. 

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

  1688.                        const char* const rtClientBaseName,

  1689.                        const char* const nonRtClientBaseName,

  1690.                        const char* const nonRtServerBaseName)

  1691. {

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

  1693. }

  1694. 

  1695. }

  1696. 

  1697. // -----------------------------------------------------------------------

  1698. 

  1699. CARLA_BACKEND_END_NAMESPACE

  1700. 

  1701. // -----------------------------------------------------------------------

  1702. 

  1703. #include "CarlaBridgeUtils.cpp"

  1704. 

  1705. // -----------------------------------------------------------------------