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.
6691 Commits
16 Branches
191MB
Tree: 2714ba4eea
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2714ba4eea'
${ noResults }
Carla/source/backend/engine/CarlaEngineBridge.cpp

1709 lines
67KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2022 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. // must be first so we can undef CARLA_SAFE_*_RETURN_ERR* macros

  23. #include "CarlaPluginInternal.hpp"

  24. #undef CARLA_SAFE_ASSERT_RETURN_ERR

  25. #undef CARLA_SAFE_ASSERT_RETURN_ERRN

  26. #undef CARLA_SAFE_EXCEPTION_RETURN_ERR

  27. #undef CARLA_SAFE_EXCEPTION_RETURN_ERRN

  28. 

  29. #include "CarlaEngineClient.hpp"

  30. #include "CarlaEngineInit.hpp"

  31. 

  32. #include "CarlaBackendUtils.hpp"

  33. #include "CarlaBase64Utils.hpp"

  34. #include "CarlaBridgeUtils.hpp"

  35. #include "CarlaMIDI.h"

  36. 

  37. #ifdef __SSE2_MATH__

  38. # include <xmmintrin.h>

  39. #endif

  40. 

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

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

  43. 

  44. // must be last

  45. #include "jackbridge/JackBridge.hpp"

  46. 

  47. using water::File;

  48. using water::MemoryBlock;

  49. using water::String;

  50. using water::Time;

  51. 

  52. CARLA_BACKEND_START_NAMESPACE

  53. 

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

  55. // Bridge Engine client

  56. 

  57. struct LatencyChangedCallback {

  58.     virtual ~LatencyChangedCallback() noexcept {}

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

  60. };

  61. 

  62. class CarlaEngineBridgeClient : public CarlaEngineClientForSubclassing

  63. {

  64. public:

  65. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  66.     CarlaEngineBridgeClient(const CarlaEngine& engine,

  67.                             EngineInternalGraph& egraph,

  68.                             const CarlaPluginPtr plugin,

  69.                             LatencyChangedCallback* const cb)

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

  71.           fLatencyCallback(cb) {}

  72. #else

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

  74.         : CarlaEngineClientForSubclassing(engine),

  75.           fLatencyCallback(cb) {}

  76. #endif

  77. 

  78. protected:

  79.     void setLatency(const uint32_t samples) noexcept override

  80.     {

  81.         if (getLatency() == samples)

  82.             return;

  83. 

  84.         fLatencyCallback->latencyChanged(samples);

  85.         CarlaEngineClient::setLatency(samples);

  86.     }

  87. 

  88. private:

  89.     LatencyChangedCallback* const fLatencyCallback;

  90. 

  91.     CARLA_DECLARE_NON_COPYABLE(CarlaEngineBridgeClient)

  92. };

  93. 

  94. // -------------------------------------------------------------------

  95. 

  96. struct BridgeTextReader {

  97.     char* text;

  98. 

  99.     BridgeTextReader(BridgeNonRtClientControl& nonRtClientCtrl)

  100.         : text(nullptr)

  101.     {

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

  103.         CARLA_SAFE_ASSERT_RETURN(size != 0,);

  104. 

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

  106.         nonRtClientCtrl.readCustomData(text, size);

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

  108.     }

  109. 

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

  111.         : text(nullptr)

  112.     {

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

  114. 

  115.         if (size != 0)

  116.             nonRtClientCtrl.readCustomData(text, size);

  117. 

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

  119.     }

  120. 

  121.     ~BridgeTextReader() noexcept

  122.     {

  123.         delete[] text;

  124.     }

  125. 

  126.     CARLA_DECLARE_NON_COPYABLE(BridgeTextReader)

  127. };

  128. 

  129. // -------------------------------------------------------------------

  130. 

  131. class CarlaEngineBridge : public CarlaEngine,

  132.                           private CarlaThread,

  133.                           private LatencyChangedCallback

  134. {

  135. public:

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

  137.         : CarlaEngine(),

  138.           CarlaThread("CarlaEngineBridge"),

  139.           fShmAudioPool(),

  140.           fShmRtClientControl(),

  141.           fShmNonRtClientControl(),

  142.           fShmNonRtServerControl(),

  143.           fBaseNameAudioPool(audioPoolBaseName),

  144.           fBaseNameRtClientControl(rtClientBaseName),

  145.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  146.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  147.           fClosingDown(false),

  148.           fIsOffline(false),

  149.           fFirstIdle(true),

  150.           fLastPingTime(-1)

  151.     {

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

  153.     }

  154. 

  155.     ~CarlaEngineBridge() noexcept override

  156.     {

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

  158. 

  159.         clear();

  160.     }

  161. 

  162.     // -------------------------------------

  163.     // CarlaEngine virtual calls

  164. 

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

  166.     {

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

  168. 

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

  170.         {

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

  172.             return false;

  173.         }

  174. 

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

  176.         {

  177.             pData->close();

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

  179.             return false;

  180.         }

  181. 

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

  183.         {

  184.             pData->close();

  185.             clear();

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

  187.             return false;

  188.         }

  189. 

  190.         if (! fShmRtClientControl.mapData())

  191.         {

  192.             pData->close();

  193.             clear();

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

  195.             return false;

  196.         }

  197. 

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

  199.         {

  200.             pData->close();

  201.             clear();

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

  203.             return false;

  204.         }

  205. 

  206.         if (! fShmNonRtClientControl.mapData())

  207.         {

  208.             pData->close();

  209.             clear();

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

  211.             return false;

  212.         }

  213. 

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

  215.         {

  216.             pData->close();

  217.             clear();

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

  219.             return false;

  220.         }

  221. 

  222.         if (! fShmNonRtServerControl.mapData())

  223.         {

  224.             pData->close();

  225.             clear();

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

  227.             return false;

  228.         }

  229. 

  230.         PluginBridgeNonRtClientOpcode opcode;

  231. 

  232.         opcode = fShmNonRtClientControl.readOpcode();

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

  234. 

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

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

  237. 

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

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

  240. 

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

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

  243. 

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

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

  246. 

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

  248.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  249.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  250.         {

  251.             pData->close();

  252.             clear();

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

  254.             return false;

  255.         }

  256. 

  257.         opcode = fShmNonRtClientControl.readOpcode();

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

  259. 

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

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

  262. 

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

  264.         {

  265.             pData->close();

  266.             clear();

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

  268.             return false;

  269.         }

  270. 

  271.         pData->initTime(nullptr);

  272. 

  273.         // tell backend we're live

  274.         {

  275.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  276. 

  277.             // kPluginBridgeNonRtServerVersion was added in API 7

  278.             if (apiVersion >= 7)

  279.             {

  280.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  281.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  282.             }

  283.             else

  284.             {

  285.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  286.             }

  287. 

  288.             fShmNonRtServerControl.commitWrite();

  289.         }

  290. 

  291.         startThread(true);

  292.         return true;

  293.     }

  294. 

  295.     bool close() override

  296.     {

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

  298.         fLastPingTime = -1;

  299. 

  300.         CarlaEngine::close();

  301. 

  302.         stopThread(5000);

  303.         clear();

  304. 

  305.         return true;

  306.     }

  307. 

  308.     bool hasIdleOnMainThread() const noexcept override

  309.     {

  310.         return true;

  311.     }

  312. 

  313.     bool isRunning() const noexcept override

  314.     {

  315.         if (fClosingDown)

  316.             return false;

  317. 

  318.         return isThreadRunning() || ! fFirstIdle;

  319.     }

  320. 

  321.     bool isOffline() const noexcept override

  322.     {

  323.         return fIsOffline;

  324.     }

  325. 

  326.     EngineType getType() const noexcept override

  327.     {

  328.         return kEngineTypeBridge;

  329.     }

  330. 

  331.     const char* getCurrentDriverName() const noexcept override

  332.     {

  333.         return "Bridge";

  334.     }

  335. 

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

  337.     {

  338.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  339. 

  340.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  341.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  342.         fShmNonRtServerControl.writeUInt(parameterId);

  343.         fShmNonRtServerControl.writeBool(touch);

  344.         fShmNonRtServerControl.commitWrite();

  345.     }

  346. 

  347.     CarlaEngineClient* addClient(const CarlaPluginPtr plugin) override

  348.     {

  349. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  351. #else

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

  353. 

  354.         // unused

  355.         (void)plugin;

  356. #endif

  357.     }

  358. 

  359.     void idle() noexcept override

  360.     {

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

  362. 

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

  364.         {

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

  366.             {

  367.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  368.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  369.                 fShmNonRtServerControl.writeUInt(length);

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

  371.                 fShmNonRtServerControl.commitWrite();

  372.             }

  373. 

  374.             signalThreadShouldExit();

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

  376.             return;

  377.         }

  378. 

  379.         const bool wasFirstIdle(fFirstIdle);

  380. 

  381.         if (wasFirstIdle)

  382.         {

  383.             fFirstIdle = false;

  384.             fLastPingTime = Time::currentTimeMillis();

  385.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  386. 

  387.             char bufStr[STR_MAX+1];

  388.             carla_zeroChars(bufStr, STR_MAX+1);

  389. 

  390.             uint32_t bufStrSize;

  391. 

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

  393.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  394. 

  395.             // kPluginBridgeNonRtServerPluginInfo1

  396.             {

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

  398.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  404.                 fShmNonRtServerControl.commitWrite();

  405.             }

  406. 

  407.             // kPluginBridgeNonRtServerPluginInfo2

  408.             {

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

  410.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  411. 

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

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

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

  415.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  416.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  417. 

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

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

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

  421.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  422.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  423. 

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

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

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

  427.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  428.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  429. 

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

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

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

  433.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  434.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  435. 

  436.                 fShmNonRtServerControl.commitWrite();

  437.             }

  438. 

  439.             // kPluginBridgeNonRtServerAudioCount

  440.             {

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

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

  443. 

  444.                 // uint/ins, uint/outs

  445.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  446.                 fShmNonRtServerControl.writeUInt(aIns);

  447.                 fShmNonRtServerControl.writeUInt(aOuts);

  448.                 fShmNonRtServerControl.commitWrite();

  449. 

  450.                 // kPluginBridgeNonRtServerPortName

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

  452.                 {

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

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

  455. 

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

  457.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  458.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  459.                     fShmNonRtServerControl.writeUInt(i);

  460. 

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

  462.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  463.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  464.                 }

  465. 

  466.                 // kPluginBridgeNonRtServerPortName

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

  468.                 {

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

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

  471. 

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

  473.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  474.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  475.                     fShmNonRtServerControl.writeUInt(i);

  476. 

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

  478.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  479.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  480.                 }

  481.             }

  482. 

  483.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  484. 

  485.             // kPluginBridgeNonRtServerMidiCount

  486.             {

  487.                 // uint/ins, uint/outs

  488.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  491.                 fShmNonRtServerControl.commitWrite();

  492.             }

  493. 

  494.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  495. 

  496.             // kPluginBridgeNonRtServerCvCount

  497.             {

  498.                 // uint/ins, uint/outs

  499.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  502.                 fShmNonRtServerControl.commitWrite();

  503.             }

  504. 

  505.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  506. 

  507.             // kPluginBridgeNonRtServerParameter*

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

  509.             {

  510.                 // uint/count

  511.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  512.                 fShmNonRtServerControl.writeUInt(count);

  513.                 fShmNonRtServerControl.commitWrite();

  514. 

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

  516.                 {

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

  518. 

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

  520.                         continue;

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

  522.                         continue;

  523. 

  524.                     // kPluginBridgeNonRtServerParameterData1

  525.                     {

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

  527.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  528.                         fShmNonRtServerControl.writeUInt(i);

  529.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  530.                         fShmNonRtServerControl.writeUInt(paramData.type);

  531.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  532.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  533.                         fShmNonRtServerControl.commitWrite();

  534.                     }

  535. 

  536.                     // kPluginBridgeNonRtServerParameterData2

  537.                     {

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

  539.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  540.                         fShmNonRtServerControl.writeUInt(i);

  541. 

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

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

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

  545.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  546.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  547. 

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

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

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

  551.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  552.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  553. 

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

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

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

  557.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  558.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  559. 

  560.                         fShmNonRtServerControl.commitWrite();

  561.                     }

  562. 

  563.                     // kPluginBridgeNonRtServerParameterRanges

  564.                     {

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

  566. 

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

  568.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  569.                         fShmNonRtServerControl.writeUInt(i);

  570.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  571.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  572.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  573.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  574.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  575.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  576.                         fShmNonRtServerControl.commitWrite();

  577.                     }

  578. 

  579.                     // kPluginBridgeNonRtServerParameterValue2

  580.                     {

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

  582.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  583.                         fShmNonRtServerControl.writeUInt(i);

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

  585.                         fShmNonRtServerControl.commitWrite();

  586.                     }

  587. 

  588.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  589.                 }

  590.             }

  591. 

  592.             // kPluginBridgeNonRtServerProgram*

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

  594.             {

  595.                 // uint/count

  596.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  597.                 fShmNonRtServerControl.writeUInt(count);

  598.                 fShmNonRtServerControl.commitWrite();

  599. 

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

  601.                 {

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

  603.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  604.                     fShmNonRtServerControl.writeUInt(i);

  605. 

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

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

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

  609.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  610.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  611. 

  612.                     fShmNonRtServerControl.commitWrite();

  613.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  614.                 }

  615.             }

  616. 

  617.             // kPluginBridgeNonRtServerMidiProgram*

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

  619.             {

  620.                 // uint/count

  621.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  622.                 fShmNonRtServerControl.writeUInt(count);

  623.                 fShmNonRtServerControl.commitWrite();

  624. 

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

  626.                 {

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

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

  629. 

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

  631.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  632.                     fShmNonRtServerControl.writeUInt(i);

  633.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  634.                     fShmNonRtServerControl.writeUInt(mpData.program);

  635. 

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

  637.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  639. 

  640.                     fShmNonRtServerControl.commitWrite();

  641.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  642.                 }

  643.             }

  644. 

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

  646.             {

  647.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  648.                 fShmNonRtServerControl.writeUInt(latency);

  649.                 fShmNonRtServerControl.commitWrite();

  650.             }

  651. 

  652.             // ready!

  653.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  654.             fShmNonRtServerControl.commitWrite();

  655.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  656. 

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

  658.             fLastPingTime = Time::currentTimeMillis();

  659.         }

  660. 

  661.         // send parameter outputs

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

  663.         {

  664.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  665. 

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

  667.             {

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

  669.                     continue;

  670. 

  671.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  672.                 fShmNonRtServerControl.writeUInt(i);

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

  674. 

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

  676.                 if (! fShmNonRtServerControl.commitWrite())

  677.                     break;

  678.             }

  679.         }

  680. 

  681.         CarlaEngine::idle();

  682. 

  683.         try {

  684.             handleNonRtData();

  685.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  686. 

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

  688.         {

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

  690.             signalThreadShouldExit();

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

  692.         }

  693.     }

  694. 

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

  696.                   const EngineCallbackOpcode action, const uint pluginId,

  697.                   const int value1, const int value2, const int value3,

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

  699.     {

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

  701. 

  702.         if (fClosingDown || ! sendHost)

  703.             return;

  704. 

  705.         switch (action)

  706.         {

  707.         // uint/index float/value

  708.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  709.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  710.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  711.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  713.             fShmNonRtServerControl.writeFloat(valuef);

  714.             fShmNonRtServerControl.commitWrite();

  715.         }   break;

  716. 

  717.         // uint/index float/value

  718.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  719.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  720.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  721.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  723.             fShmNonRtServerControl.writeFloat(valuef);

  724.             fShmNonRtServerControl.commitWrite();

  725.         }   break;

  726. 

  727.         // int/index

  728.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  729.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  730.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  731.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  732.             fShmNonRtServerControl.writeInt(value1);

  733.             fShmNonRtServerControl.commitWrite();

  734.         }   break;

  735. 

  736.         // int/index

  737.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  738.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  739.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  740.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  741.             fShmNonRtServerControl.writeInt(value1);

  742.             fShmNonRtServerControl.commitWrite();

  743.         }   break;

  744. 

  745.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  746.             if (value1 != 1)

  747.             {

  748.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  749.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  750.                 fShmNonRtServerControl.commitWrite();

  751.             }

  752.             break;

  753. 

  754.         case ENGINE_CALLBACK_EMBED_UI_RESIZED: {

  755.             CARLA_SAFE_ASSERT_BREAK(value1 > 1);

  756.             CARLA_SAFE_ASSERT_BREAK(value2 > 1);

  757. 

  758.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  759. 

  760.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerResizeEmbedUI);

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

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

  763.             fShmNonRtServerControl.commitWrite();

  764.         }   break;

  765. 

  766.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

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

  768.             {

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

  770.                 {

  771.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  772. 

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

  774.                     {

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

  776. 

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

  778.                             continue;

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

  780.                             continue;

  781. 

  782.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  783.                         fShmNonRtServerControl.writeUInt(i);

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

  785.                         fShmNonRtServerControl.commitWrite();

  786. 

  787.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  788.                     }

  789.                 }

  790.             }

  791.             break;

  792. 

  793.         default:

  794.             break;

  795.         }

  796.     }

  797. 

  798.     // -------------------------------------------------------------------

  799. 

  800.     void clear() noexcept

  801.     {

  802.         fShmAudioPool.clear();

  803.         fShmRtClientControl.clear();

  804.         fShmNonRtClientControl.clear();

  805.         fShmNonRtServerControl.clear();

  806.     }

  807. 

  808.     void handleNonRtData()

  809.     {

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

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

  812. 

  813.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  814.         {

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

  816. 

  817. #ifdef DEBUG

  818.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  820.                             opcode, PluginBridgeNonRtClientOpcode2str(opcode));

  821.             }

  822. #endif

  823. 

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

  825.                 fLastPingTime = Time::currentTimeMillis();

  826. 

  827.             switch (opcode)

  828.             {

  829.             case kPluginBridgeNonRtClientNull:

  830.                 break;

  831. 

  832.             case kPluginBridgeNonRtClientVersion: {

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

  834.                 CARLA_SAFE_ASSERT_UINT2(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  835.                                         apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  836.             }   break;

  837. 

  838.             case kPluginBridgeNonRtClientPing: {

  839.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  840. 

  841.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  842.                 fShmNonRtServerControl.commitWrite();

  843.             }   break;

  844. 

  845.             case kPluginBridgeNonRtClientPingOnOff: {

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

  847. 

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

  849.             }   break;

  850. 

  851.             case kPluginBridgeNonRtClientActivate:

  852.                 if (plugin->isEnabled())

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

  854.                 break;

  855. 

  856.             case kPluginBridgeNonRtClientDeactivate:

  857.                 if (plugin->isEnabled())

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

  859.                 break;

  860. 

  861.             case kPluginBridgeNonRtClientInitialSetup:

  862.                 // should never happen!!

  863.                 fShmNonRtServerControl.readUInt();

  864.                 fShmNonRtServerControl.readDouble();

  865.                 break;

  866. 

  867.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  870. 

  871.                 if (plugin->isEnabled())

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

  873.                 break;

  874.             }

  875. 

  876.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  879. 

  880.                 if (plugin->isEnabled())

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

  882.                 break;

  883.             }

  884. 

  885.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

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

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

  888. 

  889.                 if (plugin->isEnabled())

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

  891.                 break;

  892.             }

  893. 

  894.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  898. 

  899.                 if (plugin->isEnabled())

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

  901.                 break;

  902.             }

  903. 

  904.             case kPluginBridgeNonRtClientSetProgram: {

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

  906. 

  907.                 if (plugin->isEnabled())

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

  909.                 break;

  910.             }

  911. 

  912.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  914. 

  915.                 if (plugin->isEnabled())

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

  917.                 break;

  918.             }

  919. 

  920.             case kPluginBridgeNonRtClientSetCustomData: {

  921.                 // type

  922.                 const BridgeTextReader type(fShmNonRtClientControl);

  923. 

  924.                 // key

  925.                 const BridgeTextReader key(fShmNonRtClientControl);

  926. 

  927.                 // value

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

  929. 

  930.                 if (valueSize > 0)

  931.                 {

  932.                     if (valueSize > 16384)

  933.                     {

  934.                         const BridgeTextReader bigValueFilePathTry(fShmNonRtClientControl, valueSize);

  935. 

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

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

  938. 

  939.                         String bigValueFilePath(bigValueFilePathTry.text);

  940. 

  941. #ifdef CARLA_OS_WIN

  942.                         // check if running under Wine

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

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

  945. #endif

  946. 

  947.                         File bigValueFile(bigValueFilePath);

  948.                         CARLA_SAFE_ASSERT_BREAK(bigValueFile.existsAsFile());

  949. 

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

  951. 

  952.                         bigValueFile.deleteFile();

  953.                     }

  954.                     else

  955.                     {

  956.                         const BridgeTextReader value(fShmNonRtClientControl, valueSize);

  957. 

  958.                         if (plugin->isEnabled())

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

  960.                     }

  961.                 }

  962.                 else

  963.                 {

  964.                     if (plugin->isEnabled())

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

  966.                 }

  967. 

  968.                 break;

  969.             }

  970. 

  971.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  973.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  974. 

  975.                 const BridgeTextReader chunkFilePathTry(fShmNonRtClientControl, size);

  976. 

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

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

  979. 

  980.                 String chunkFilePath(chunkFilePathTry.text);

  981. 

  982. #ifdef CARLA_OS_WIN

  983.                 // check if running under Wine

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

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

  986. #endif

  987. 

  988.                 File chunkFile(chunkFilePath);

  989.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  990. 

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

  992.                 chunkFile.deleteFile();

  993.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  994. 

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

  996. 

  997. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  999. #else

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

  1001. #endif

  1002.                 break;

  1003.             }

  1004. 

  1005.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  1008. 

  1009.                 if (plugin->isEnabled())

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

  1011.                 break;

  1012.             }

  1013. 

  1014.             case kPluginBridgeNonRtClientSetOption: {

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

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

  1017. 

  1018.                 if (plugin->isEnabled())

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

  1020.                 break;

  1021.             }

  1022. 

  1023.             case kPluginBridgeNonRtClientSetOptions: {

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

  1025. 

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

  1027.                 break;

  1028.             }

  1029. 

  1030.             case kPluginBridgeNonRtClientSetWindowTitle: {

  1031.                 const BridgeTextReader title(fShmNonRtClientControl);

  1032. 

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

  1034.                 break;

  1035.             }

  1036. 

  1037.             case kPluginBridgeNonRtClientGetParameterText: {

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

  1039. 

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

  1041.                 {

  1042.                     char bufStr[STR_MAX+1];

  1043.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  1046. 

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

  1048. 

  1049.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1050. 

  1051.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1052. 

  1053.                     fShmNonRtServerControl.writeInt(index);

  1054.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  1055.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  1056.                     fShmNonRtServerControl.commitWrite();

  1057. 

  1058.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1059.                 }

  1060.                 else

  1061.                 {

  1062.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1063. 

  1064.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1065.                     fShmNonRtServerControl.writeInt(index);

  1066.                     fShmNonRtServerControl.writeUInt(0);

  1067.                     fShmNonRtServerControl.commitWrite();

  1068.                 }

  1069. 

  1070.                 break;

  1071.             }

  1072. 

  1073.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1075.                 {

  1076.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1077.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1078.                     fShmNonRtServerControl.commitWrite();

  1079.                     return;

  1080.                 }

  1081. 

  1082.                 plugin->prepareForSave(false);

  1083. 

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

  1085.                 {

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

  1087. 

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

  1089.                         continue;

  1090. 

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

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

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

  1094. 

  1095.                     if (valueLen > 16384)

  1096.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1097. 

  1098.                     {

  1099.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1100. 

  1101.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1102. 

  1103.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1105. 

  1106.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1108. 

  1109.                         fShmNonRtServerControl.writeUInt(valueLen);

  1110. 

  1111.                         if (valueLen > 0)

  1112.                         {

  1113.                             if (valueLen > 16384)

  1114.                             {

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

  1116. 

  1117.                                 filePath += CARLA_OS_SEP_STR ".CarlaCustomData_";

  1118.                                 filePath += fShmAudioPool.getFilenameSuffix();

  1119. 

  1120.                                 if (File(filePath).replaceWithText(cdata.value))

  1121.                                 {

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

  1123. 

  1124.                                     fShmNonRtServerControl.writeUInt(ulength);

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

  1126.                                 }

  1127.                                 else

  1128.                                 {

  1129.                                     fShmNonRtServerControl.writeUInt(0);

  1130.                                 }

  1131.                             }

  1132.                             else

  1133.                             {

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

  1135.                             }

  1136.                         }

  1137. 

  1138.                         fShmNonRtServerControl.commitWrite();

  1139.                     }

  1140. 

  1141.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1142.                 }

  1143. 

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

  1145.                 {

  1146.                     void* data = nullptr;

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

  1148.                     {

  1149.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1150. 

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

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

  1153. 

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

  1155. 

  1156.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1157.                         filePath += fShmAudioPool.getFilenameSuffix();

  1158. 

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

  1160.                         {

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

  1162. 

  1163.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1164. 

  1165.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1166.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1168.                             fShmNonRtServerControl.commitWrite();

  1169.                         }

  1170.                     }

  1171.                 }

  1172. 

  1173.                 {

  1174.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1175. 

  1176.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1177.                     fShmNonRtServerControl.commitWrite();

  1178.                 }

  1179.                 break;

  1180.             }

  1181. 

  1182.             case kPluginBridgeNonRtClientRestoreLV2State:

  1183.                 if (plugin->isEnabled())

  1184.                     plugin->restoreLV2State(false);

  1185.                 break;

  1186. 

  1187.             case kPluginBridgeNonRtClientShowUI:

  1188.                 if (plugin->isEnabled())

  1189.                     plugin->showCustomUI(true);

  1190.                 break;

  1191. 

  1192.             case kPluginBridgeNonRtClientHideUI:

  1193.                 if (plugin->isEnabled())

  1194.                     plugin->showCustomUI(false);

  1195.                 break;

  1196. 

  1197.             case kPluginBridgeNonRtClientEmbedUI: {

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

  1199.                 uint64_t resp = 0;

  1200. 

  1201.                 if (plugin->isEnabled())

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

  1203. 

  1204.                 if (resp == 0)

  1205.                     resp = 1;

  1206. 

  1207.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1208. 

  1209.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerRespEmbedUI);

  1210.                 fShmNonRtServerControl.writeULong(resp);

  1211.                 fShmNonRtServerControl.commitWrite();

  1212.                 break;

  1213.             }

  1214. 

  1215.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1218. 

  1219.                 if (plugin->isEnabled())

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

  1221.                 break;

  1222.             }

  1223. 

  1224.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1226. 

  1227.                 if (plugin->isEnabled())

  1228.                     plugin->uiProgramChange(index);

  1229.                 break;

  1230.             }

  1231. 

  1232.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1234. 

  1235.                 if (plugin->isEnabled())

  1236.                     plugin->uiMidiProgramChange(index);

  1237.                 break;

  1238.             }

  1239. 

  1240.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1244. 

  1245.                 if (plugin->isEnabled())

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

  1247.                 break;

  1248.             }

  1249. 

  1250.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1253. 

  1254.                 if (plugin->isEnabled())

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

  1256.                 break;

  1257.             }

  1258. 

  1259.             case kPluginBridgeNonRtClientQuit:

  1260.                 fClosingDown = true;

  1261.                 signalThreadShouldExit();

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

  1263.                 break;

  1264.             }

  1265.         }

  1266.     }

  1267. 

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

  1269. 

  1270. protected:

  1271.     void run() override

  1272.     {

  1273. #ifdef __SSE2_MATH__

  1274.         // Set FTZ and DAZ flags

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

  1276. #endif

  1277. 

  1278.         bool quitReceived = false;

  1279. 

  1280.         for (; ! shouldThreadExit();)

  1281.         {

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

  1283. 

  1284.             if (! helper.ok)

  1285.                 continue;

  1286. 

  1287.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1288.             {

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

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

  1291. 

  1292. #ifdef DEBUG

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

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

  1295.                 }

  1296. #endif

  1297. 

  1298.                 switch (opcode)

  1299.                 {

  1300.                 case kPluginBridgeRtClientNull:

  1301.                     break;

  1302. 

  1303.                 case kPluginBridgeRtClientSetAudioPool: {

  1304.                     if (fShmAudioPool.data != nullptr)

  1305.                     {

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

  1307.                         fShmAudioPool.data = nullptr;

  1308.                     }

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

  1310.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1312.                     break;

  1313.                 }

  1314. 

  1315.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1317.                     pData->bufferSize = bufferSize;

  1318.                     bufferSizeChanged(bufferSize);

  1319.                     break;

  1320.                 }

  1321. 

  1322.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1324.                     pData->sampleRate = sampleRate;

  1325.                     sampleRateChanged(sampleRate);

  1326.                     break;

  1327.                 }

  1328. 

  1329.                 case kPluginBridgeRtClientSetOnline:

  1330.                     fIsOffline = fShmRtClientControl.readBool();

  1331.                     offlineModeChanged(fIsOffline);

  1332.                     break;

  1333. 

  1334.                 // NOTE this is never used

  1335.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1340. 

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

  1342.                     {

  1343.                         event->type                 = kEngineEventTypeControl;

  1344.                         event->time                 = time;

  1345.                         event->channel              = channel;

  1346.                         event->ctrl.type            = kEngineControlEventTypeParameter;

  1347.                         event->ctrl.param           = param;

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

  1349.                         event->ctrl.normalizedValue = value;

  1350.                         event->ctrl.handled         = true;

  1351.                     }

  1352.                     break;

  1353.                 }

  1354. 

  1355.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1359. 

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

  1361.                     {

  1362.                         event->type                 = kEngineEventTypeControl;

  1363.                         event->time                 = time;

  1364.                         event->channel              = channel;

  1365.                         event->ctrl.type            = kEngineControlEventTypeMidiBank;

  1366.                         event->ctrl.param           = index;

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

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

  1369.                         event->ctrl.handled         = true;

  1370.                     }

  1371.                     break;

  1372.                 }

  1373. 

  1374.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1378. 

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

  1380.                     {

  1381.                         event->type                 = kEngineEventTypeControl;

  1382.                         event->time                 = time;

  1383.                         event->channel              = channel;

  1384.                         event->ctrl.type            = kEngineControlEventTypeMidiProgram;

  1385.                         event->ctrl.param           = index;

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

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

  1388.                         event->ctrl.handled         = true;

  1389.                     }

  1390.                     break;

  1391.                 }

  1392. 

  1393.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1396. 

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

  1398.                     {

  1399.                         event->type                 = kEngineEventTypeControl;

  1400.                         event->time                 = time;

  1401.                         event->channel              = channel;

  1402.                         event->ctrl.type            = kEngineControlEventTypeAllSoundOff;

  1403.                         event->ctrl.param           = 0;

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

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

  1406.                         event->ctrl.handled         = true;

  1407.                     }

  1408.                 }   break;

  1409. 

  1410.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1413. 

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

  1415.                     {

  1416.                         event->type                 = kEngineEventTypeControl;

  1417.                         event->time                 = time;

  1418.                         event->channel              = channel;

  1419.                         event->ctrl.type            = kEngineControlEventTypeAllNotesOff;

  1420.                         event->ctrl.param           = 0;

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

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

  1423.                         event->ctrl.handled         = true;

  1424.                     }

  1425.                 }   break;

  1426. 

  1427.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1431.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1432. 

  1433.                     // FIXME variable-size stack

  1434.                     uint8_t data[4];

  1435. 

  1436.                     {

  1437.                         uint8_t i=0;

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

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

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

  1441.                             fShmRtClientControl.readByte();

  1442.                     }

  1443. 

  1444.                     if (size > 4)

  1445.                         continue;

  1446. 

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

  1448.                     {

  1449.                         event->type    = kEngineEventTypeMidi;

  1450.                         event->time    = time;

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

  1452. 

  1453.                         event->midi.port = port;

  1454.                         event->midi.size = size;

  1455. 

  1456.                         if (size > EngineMidiEvent::kDataSize)

  1457.                         {

  1458.                             event->midi.dataExt = data;

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

  1460.                         }

  1461.                         else

  1462.                         {

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

  1464. 

  1465.                             uint8_t i=1;

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

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

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

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

  1470. 

  1471.                             event->midi.dataExt = nullptr;

  1472.                         }

  1473.                     }

  1474.                     break;

  1475.                 }

  1476. 

  1477.                 case kPluginBridgeRtClientProcess: {

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

  1479. 

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

  1481. 

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

  1483.                     {

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

  1485. 

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

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

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

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

  1490. 

  1491.                         const float* audioIn[64];

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

  1493.                         const float* cvIn[32];

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

  1495. 

  1496.                         float* fdata = fShmAudioPool.data;

  1497. 

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

  1499.                             audioIn[i] = fdata;

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

  1501.                             audioOut[i] = fdata;

  1502. 

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

  1504.                             cvIn[i] = fdata;

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

  1506.                             cvOut[i] = fdata;

  1507. 

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

  1509. 

  1510.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1511.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1512.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1514. 

  1515.                         if (timeInfo.bbt.valid)

  1516.                         {

  1517.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1518.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1519.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1520. 

  1521.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1522.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1523. 

  1524.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1525.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1526.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1527.                         }

  1528. 

  1529.                         plugin->initBuffers();

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

  1531.                         plugin->unlock();

  1532.                     }

  1533. 

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

  1535.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1536.                     std::size_t curMidiDataPos = 0;

  1537. 

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

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

  1540. 

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

  1542.                     {

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

  1544.                         {

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

  1546. 

  1547.                             if (event.type == kEngineEventTypeNull)

  1548.                                 break;

  1549. 

  1550.                             if (event.type == kEngineEventTypeControl)

  1551.                             {

  1552.                                 uint8_t data[3];

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

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

  1555. 

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

  1557.                                     break;

  1558. 

  1559.                                 // set time

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

  1561.                                 midiData = midiData + 4;

  1562.                                 curMidiDataPos += 4;

  1563. 

  1564.                                 // set port

  1565.                                 *midiData++ = 0;

  1566.                                 ++curMidiDataPos;

  1567. 

  1568.                                 // set size

  1569.                                 *midiData++ = size;

  1570.                                 ++curMidiDataPos;

  1571. 

  1572.                                 // set data

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

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

  1575. 

  1576.                                 curMidiDataPos += size;

  1577.                             }

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

  1579.                             {

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

  1581. 

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

  1583.                                     break;

  1584. 

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

  1586. 

  1587.                                 // set time

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

  1589.                                 midiData += 4;

  1590.                                 curMidiDataPos += 4;

  1591. 

  1592.                                 // set port

  1593.                                 *midiData++ = _midiEvent.port;

  1594.                                 ++curMidiDataPos;

  1595. 

  1596.                                 // set size

  1597.                                 *midiData++ = _midiEvent.size;

  1598.                                 ++curMidiDataPos;

  1599. 

  1600.                                 // set data

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

  1602. 

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

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

  1605. 

  1606.                                 curMidiDataPos += _midiEvent.size;

  1607.                             }

  1608.                         }

  1609. 

  1610.                         if (curMidiDataPos != 0 &&

  1611.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1612.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1613. 

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

  1615.                     }

  1616. 

  1617.                 }   break;

  1618. 

  1619.                 case kPluginBridgeRtClientQuit: {

  1620.                     quitReceived = true;

  1621.                     fClosingDown = true;

  1622.                     signalThreadShouldExit();

  1623.                 }   break;

  1624.                 }

  1625.             }

  1626.         }

  1627. 

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

  1629. 

  1630.         if (! quitReceived)

  1631.         {

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

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

  1634. 

  1635.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1636.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1637.             fShmNonRtServerControl.writeUInt(messageSize);

  1638.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1639.             fShmNonRtServerControl.commitWrite();

  1640.         }

  1641.     }

  1642. 

  1643.     // called from process thread above

  1644.     EngineEvent* getNextFreeInputEvent() const noexcept

  1645.     {

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

  1647.         {

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

  1649. 

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

  1651.                 return event;

  1652.         }

  1653.         return nullptr;

  1654.     }

  1655. 

  1656.     void latencyChanged(const uint32_t samples) noexcept override

  1657.     {

  1658.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1659. 

  1660.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1661.         fShmNonRtServerControl.writeUInt(samples);

  1662.         fShmNonRtServerControl.commitWrite();

  1663.     }

  1664. 

  1665.     // -------------------------------------------------------------------

  1666. 

  1667. private:

  1668.     BridgeAudioPool          fShmAudioPool;

  1669.     BridgeRtClientControl    fShmRtClientControl;

  1670.     BridgeNonRtClientControl fShmNonRtClientControl;

  1671.     BridgeNonRtServerControl fShmNonRtServerControl;

  1672. 

  1673.     CarlaString fBaseNameAudioPool;

  1674.     CarlaString fBaseNameRtClientControl;

  1675.     CarlaString fBaseNameNonRtClientControl;

  1676.     CarlaString fBaseNameNonRtServerControl;

  1677. 

  1678.     bool fClosingDown;

  1679.     bool fIsOffline;

  1680.     bool fFirstIdle;

  1681.     int64_t fLastPingTime;

  1682. 

  1683.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1684. };

  1685. 

  1686. // -----------------------------------------------------------------------

  1687. 

  1688. namespace EngineInit {

  1689. 

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

  1691.                        const char* const rtClientBaseName,

  1692.                        const char* const nonRtClientBaseName,

  1693.                        const char* const nonRtServerBaseName)

  1694. {

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

  1696. }

  1697. 

  1698. }

  1699. 

  1700. // -----------------------------------------------------------------------

  1701. 

  1702. CARLA_BACKEND_END_NAMESPACE

  1703. 

  1704. // -----------------------------------------------------------------------

  1705. 

  1706. #include "CarlaBridgeUtils.cpp"

  1707. 

  1708. // -----------------------------------------------------------------------