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

1690 lines
68KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2023 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. class CarlaEngineBridge : public CarlaEngine,

  97.                           private CarlaThread,

  98.                           private LatencyChangedCallback

  99. {

  100. public:

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

  102.         : CarlaEngine(),

  103.           CarlaThread("CarlaEngineBridge"),

  104.           fShmAudioPool(),

  105.           fShmRtClientControl(),

  106.           fShmNonRtClientControl(),

  107.           fShmNonRtServerControl(),

  108.           fBaseNameAudioPool(audioPoolBaseName),

  109.           fBaseNameRtClientControl(rtClientBaseName),

  110.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  111.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  112.           fClosingDown(false),

  113.           fIsOffline(false),

  114.           fFirstIdle(true),

  115.           fBridgeVersion(0),

  116.           fLastPingTime(-1)

  117.     {

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

  119.     }

  120. 

  121.     ~CarlaEngineBridge() noexcept override

  122.     {

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

  124. 

  125.         clear();

  126.     }

  127. 

  128.     // -------------------------------------

  129.     // CarlaEngine virtual calls

  130. 

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

  132.     {

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

  134. 

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

  136.         {

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

  138.             return false;

  139.         }

  140. 

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

  142.         {

  143.             pData->close();

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

  145.             return false;

  146.         }

  147. 

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

  149.         {

  150.             pData->close();

  151.             clear();

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

  153.             return false;

  154.         }

  155. 

  156.         if (! fShmRtClientControl.mapData())

  157.         {

  158.             pData->close();

  159.             clear();

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

  161.             return false;

  162.         }

  163. 

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

  165.         {

  166.             pData->close();

  167.             clear();

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

  169.             return false;

  170.         }

  171. 

  172.         if (! fShmNonRtClientControl.mapData())

  173.         {

  174.             pData->close();

  175.             clear();

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

  177.             return false;

  178.         }

  179. 

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

  181.         {

  182.             pData->close();

  183.             clear();

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

  185.             return false;

  186.         }

  187. 

  188.         if (! fShmNonRtServerControl.mapData())

  189.         {

  190.             pData->close();

  191.             clear();

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

  193.             return false;

  194.         }

  195. 

  196.         PluginBridgeNonRtClientOpcode opcode;

  197. 

  198.         opcode = fShmNonRtClientControl.readOpcode();

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

  200. 

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

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

  203. 

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

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

  206. 

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

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

  209. 

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

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

  212. 

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

  214.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  215.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  216.         {

  217.             pData->close();

  218.             clear();

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

  220.             return false;

  221.         }

  222. 

  223.         opcode = fShmNonRtClientControl.readOpcode();

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

  225. 

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

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

  228. 

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

  230.         {

  231.             pData->close();

  232.             clear();

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

  234.             return false;

  235.         }

  236. 

  237.         pData->initTime(nullptr);

  238. 

  239.         // tell backend we're live

  240.         {

  241.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  242. 

  243.             // kPluginBridgeNonRtServerVersion was added in API 7

  244.             if (apiVersion >= 7)

  245.             {

  246.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  247.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  248.             }

  249.             else

  250.             {

  251.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  252.             }

  253. 

  254.             fShmNonRtServerControl.commitWrite();

  255.         }

  256. 

  257.         startThread(true);

  258.         return true;

  259.     }

  260. 

  261.     bool close() override

  262.     {

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

  264.         fLastPingTime = -1;

  265. 

  266.         CarlaEngine::close();

  267. 

  268.         stopThread(5000);

  269.         clear();

  270. 

  271.         return true;

  272.     }

  273. 

  274.     bool isRunning() const noexcept override

  275.     {

  276.         if (fClosingDown)

  277.             return false;

  278. 

  279.         return isThreadRunning() || ! fFirstIdle;

  280.     }

  281. 

  282.     bool isOffline() const noexcept override

  283.     {

  284.         return fIsOffline;

  285.     }

  286. 

  287.     EngineType getType() const noexcept override

  288.     {

  289.         return kEngineTypeBridge;

  290.     }

  291. 

  292.     const char* getCurrentDriverName() const noexcept override

  293.     {

  294.         return "Bridge";

  295.     }

  296. 

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

  298.     {

  299.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  300. 

  301.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  302.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  303.         fShmNonRtServerControl.writeUInt(parameterId);

  304.         fShmNonRtServerControl.writeBool(touch);

  305.         fShmNonRtServerControl.commitWrite();

  306.     }

  307. 

  308.     CarlaEngineClient* addClient(const CarlaPluginPtr plugin) override

  309.     {

  310. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  312. #else

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

  314. 

  315.         // unused

  316.         (void)plugin;

  317. #endif

  318.     }

  319. 

  320.     void idle() noexcept override

  321.     {

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

  323. 

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

  325.         {

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

  327.             {

  328.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  329.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  330.                 fShmNonRtServerControl.writeUInt(length);

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

  332.                 fShmNonRtServerControl.commitWrite();

  333.             }

  334. 

  335.             signalThreadShouldExit();

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

  337.             return;

  338.         }

  339. 

  340.         const bool wasFirstIdle = fFirstIdle;

  341. 

  342.         if (wasFirstIdle)

  343.         {

  344.             fFirstIdle = false;

  345.             fLastPingTime = Time::currentTimeMillis();

  346.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  347. 

  348.             char bufStr[STR_MAX+1];

  349.             carla_zeroChars(bufStr, STR_MAX+1);

  350. 

  351.             uint32_t bufStrSize;

  352. 

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

  354.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  355. 

  356.             // kPluginBridgeNonRtServerPluginInfo1

  357.             {

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

  359.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  365.                 fShmNonRtServerControl.commitWrite();

  366.             }

  367. 

  368.             // kPluginBridgeNonRtServerPluginInfo2

  369.             {

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

  371.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  372. 

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

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

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

  376.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  377.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  378. 

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

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

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

  382.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  383.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  384. 

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

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

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

  388.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  389.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  390. 

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

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

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

  394.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  395.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  396. 

  397.                 fShmNonRtServerControl.commitWrite();

  398.             }

  399. 

  400.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  401. 

  402.             // kPluginBridgeNonRtServerAudioCount

  403.             {

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

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

  406. 

  407.                 // uint/ins, uint/outs

  408.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  409.                 fShmNonRtServerControl.writeUInt(aIns);

  410.                 fShmNonRtServerControl.writeUInt(aOuts);

  411.                 fShmNonRtServerControl.commitWrite();

  412. 

  413.                 // kPluginBridgeNonRtServerPortName

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

  415.                 {

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

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

  418. 

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

  420.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  421.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  422.                     fShmNonRtServerControl.writeUInt(i);

  423. 

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

  425.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  426.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  427.                 }

  428. 

  429.                 // kPluginBridgeNonRtServerPortName

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

  431.                 {

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

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

  434. 

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

  436.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  437.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  438.                     fShmNonRtServerControl.writeUInt(i);

  439. 

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

  441.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  442.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  443.                 }

  444.             }

  445. 

  446.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  447. 

  448.             // kPluginBridgeNonRtServerMidiCount

  449.             {

  450.                 // uint/ins, uint/outs

  451.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  454.                 fShmNonRtServerControl.commitWrite();

  455.             }

  456. 

  457.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  458. 

  459.             // kPluginBridgeNonRtServerCvCount

  460.             {

  461.                 // uint/ins, uint/outs

  462.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  465.                 fShmNonRtServerControl.commitWrite();

  466.             }

  467. 

  468.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  469. 

  470.             // kPluginBridgeNonRtServerParameter*

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

  472.             {

  473.                 // uint/count

  474.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  475.                 fShmNonRtServerControl.writeUInt(count);

  476.                 fShmNonRtServerControl.commitWrite();

  477. 

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

  479.                 {

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

  481. 

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

  483.                         continue;

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

  485.                         continue;

  486. 

  487.                     // kPluginBridgeNonRtServerParameterData1

  488.                     {

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

  490.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  491.                         fShmNonRtServerControl.writeUInt(i);

  492.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  493.                         fShmNonRtServerControl.writeUInt(paramData.type);

  494.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  495.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  496.                         fShmNonRtServerControl.commitWrite();

  497.                     }

  498. 

  499.                     // kPluginBridgeNonRtServerParameterData2

  500.                     {

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

  502.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  503.                         fShmNonRtServerControl.writeUInt(i);

  504. 

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

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

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

  508.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  509.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  510. 

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

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

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

  514.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  515.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  516. 

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

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

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

  520.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  521.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  522. 

  523.                         fShmNonRtServerControl.commitWrite();

  524.                     }

  525. 

  526.                     // kPluginBridgeNonRtServerParameterRanges

  527.                     {

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

  529. 

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

  531.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  532.                         fShmNonRtServerControl.writeUInt(i);

  533.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  534.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  535.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  536.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  537.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  538.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  539.                         fShmNonRtServerControl.commitWrite();

  540.                     }

  541. 

  542.                     // kPluginBridgeNonRtServerParameterValue2

  543.                     {

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

  545.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  546.                         fShmNonRtServerControl.writeUInt(i);

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

  548.                         fShmNonRtServerControl.commitWrite();

  549.                     }

  550. 

  551.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  552.                 }

  553.             }

  554. 

  555.             // kPluginBridgeNonRtServerProgram*

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

  557.             {

  558.                 // uint/count

  559.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  560.                 fShmNonRtServerControl.writeUInt(count);

  561.                 fShmNonRtServerControl.commitWrite();

  562. 

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

  564.                 {

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

  566.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  567.                     fShmNonRtServerControl.writeUInt(i);

  568. 

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

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

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

  572.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  573.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  574. 

  575.                     fShmNonRtServerControl.commitWrite();

  576.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  577.                 }

  578.             }

  579. 

  580.             // kPluginBridgeNonRtServerMidiProgram*

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

  582.             {

  583.                 // uint/count

  584.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  585.                 fShmNonRtServerControl.writeUInt(count);

  586.                 fShmNonRtServerControl.commitWrite();

  587. 

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

  589.                 {

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

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

  592. 

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

  594.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  595.                     fShmNonRtServerControl.writeUInt(i);

  596.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  597.                     fShmNonRtServerControl.writeUInt(mpData.program);

  598. 

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

  600.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  602. 

  603.                     fShmNonRtServerControl.commitWrite();

  604.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  605.                 }

  606.             }

  607. 

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

  609.             {

  610.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  611.                 fShmNonRtServerControl.writeUInt(latency);

  612.                 fShmNonRtServerControl.commitWrite();

  613.             }

  614. 

  615.             // ready!

  616.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  617.             fShmNonRtServerControl.commitWrite();

  618.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  619. 

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

  621.             fLastPingTime = Time::currentTimeMillis();

  622.         }

  623. 

  624.         // send parameter outputs

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

  626.         {

  627.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  628. 

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

  630.             {

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

  632.                     continue;

  633. 

  634.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  635.                 fShmNonRtServerControl.writeUInt(i);

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

  637. 

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

  639.                 if (! fShmNonRtServerControl.commitWrite())

  640.                     break;

  641.             }

  642.         }

  643. 

  644.         CarlaEngine::idle();

  645. 

  646.         try {

  647.             handleNonRtData();

  648.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  649. 

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

  651.         {

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

  653.             signalThreadShouldExit();

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

  655.         }

  656.     }

  657. 

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

  659.                   const EngineCallbackOpcode action, const uint pluginId,

  660.                   const int value1, const int value2, const int value3,

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

  662.     {

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

  664. 

  665.         if (fClosingDown || ! sendHost)

  666.             return;

  667. 

  668.         switch (action)

  669.         {

  670.         // uint/index float/value

  671.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  672.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  673.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  674.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  676.             fShmNonRtServerControl.writeFloat(valuef);

  677.             fShmNonRtServerControl.commitWrite();

  678.         }   break;

  679. 

  680.         // uint/index float/value

  681.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  682.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  683.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  684.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  686.             fShmNonRtServerControl.writeFloat(valuef);

  687.             fShmNonRtServerControl.commitWrite();

  688.         }   break;

  689. 

  690.         // int/index

  691.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  692.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  693.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  694.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  695.             fShmNonRtServerControl.writeInt(value1);

  696.             fShmNonRtServerControl.commitWrite();

  697.         }   break;

  698. 

  699.         // int/index

  700.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  701.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  702.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  703.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  704.             fShmNonRtServerControl.writeInt(value1);

  705.             fShmNonRtServerControl.commitWrite();

  706.         }   break;

  707. 

  708.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  709.             if (value1 != 1)

  710.             {

  711.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  712.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  713.                 fShmNonRtServerControl.commitWrite();

  714.             }

  715.             break;

  716. 

  717.         case ENGINE_CALLBACK_EMBED_UI_RESIZED: {

  718.             CARLA_SAFE_ASSERT_BREAK(value1 > 1);

  719.             CARLA_SAFE_ASSERT_BREAK(value2 > 1);

  720. 

  721.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  722. 

  723.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerResizeEmbedUI);

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

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

  726.             fShmNonRtServerControl.commitWrite();

  727.         }   break;

  728. 

  729.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

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

  731.             {

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

  733.                 {

  734.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  735. 

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

  737.                     {

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

  739. 

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

  741.                             continue;

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

  743.                             continue;

  744. 

  745.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  746.                         fShmNonRtServerControl.writeUInt(i);

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

  748.                         fShmNonRtServerControl.commitWrite();

  749. 

  750.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  751.                     }

  752.                 }

  753.             }

  754.             break;

  755. 

  756.         default:

  757.             break;

  758.         }

  759.     }

  760. 

  761.     // -------------------------------------------------------------------

  762. 

  763.     void clear() noexcept

  764.     {

  765.         fShmAudioPool.clear();

  766.         fShmRtClientControl.clear();

  767.         fShmNonRtClientControl.clear();

  768.         fShmNonRtServerControl.clear();

  769.     }

  770. 

  771.     void handleNonRtData()

  772.     {

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

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

  775. 

  776.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  777.         {

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

  779. 

  780. #ifdef DEBUG

  781.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  783.                             opcode, PluginBridgeNonRtClientOpcode2str(opcode));

  784.             }

  785. #endif

  786. 

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

  788.                 fLastPingTime = Time::currentTimeMillis();

  789. 

  790.             switch (opcode)

  791.             {

  792.             case kPluginBridgeNonRtClientNull:

  793.                 break;

  794. 

  795.             case kPluginBridgeNonRtClientVersion: {

  796.                 fBridgeVersion = fShmNonRtServerControl.readUInt();

  797.                 CARLA_SAFE_ASSERT_UINT2(fBridgeVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  798.                                         fBridgeVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  799.             }   break;

  800. 

  801.             case kPluginBridgeNonRtClientPing: {

  802.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  803. 

  804.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  805.                 fShmNonRtServerControl.commitWrite();

  806.             }   break;

  807. 

  808.             case kPluginBridgeNonRtClientPingOnOff: {

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

  810. 

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

  812.             }   break;

  813. 

  814.             case kPluginBridgeNonRtClientActivate:

  815.                 if (plugin->isEnabled())

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

  817.                 break;

  818. 

  819.             case kPluginBridgeNonRtClientDeactivate:

  820.                 if (plugin->isEnabled())

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

  822.                 break;

  823. 

  824.             case kPluginBridgeNonRtClientInitialSetup:

  825.                 // should never happen!!

  826.                 fShmNonRtServerControl.readUInt();

  827.                 fShmNonRtServerControl.readDouble();

  828.                 break;

  829. 

  830.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  833. 

  834.                 if (plugin->isEnabled())

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

  836.                 break;

  837.             }

  838. 

  839.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  842. 

  843.                 if (plugin->isEnabled())

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

  845.                 break;

  846.             }

  847. 

  848.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

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

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

  851. 

  852.                 if (plugin->isEnabled())

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

  854.                 break;

  855.             }

  856. 

  857.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  861. 

  862.                 if (plugin->isEnabled())

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

  864.                 break;

  865.             }

  866. 

  867.             case kPluginBridgeNonRtClientSetProgram: {

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

  869. 

  870.                 if (plugin->isEnabled())

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

  872.                 break;

  873.             }

  874. 

  875.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  877. 

  878.                 if (plugin->isEnabled())

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

  880.                 break;

  881.             }

  882. 

  883.             case kPluginBridgeNonRtClientSetCustomData: {

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

  885. 

  886.                 // type

  887.                 const uint32_t typeSize = fShmNonRtClientControl.readUInt();

  888.                 char typeStr[typeSize+1];

  889.                 carla_zeroChars(typeStr, typeSize+1);

  890.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  891. 

  892.                 // key

  893.                 const uint32_t keySize = fShmNonRtClientControl.readUInt();

  894.                 char keyStr[keySize+1];

  895.                 carla_zeroChars(keyStr, keySize+1);

  896.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  897. 

  898.                 // value

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

  900. 

  901.                 if (valueSize > 0)

  902.                 {

  903.                     if (valueSize > maxLocalValueLen)

  904.                     {

  905.                         const uint32_t bigValueFilePathSize = fShmNonRtClientControl.readUInt();

  906.                         char bigValueFilePathTry[bigValueFilePathSize+1];

  907.                         carla_zeroChars(bigValueFilePathTry, bigValueFilePathSize+1);

  908.                         fShmNonRtClientControl.readCustomData(bigValueFilePathTry, bigValueFilePathSize);

  909. 

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

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

  912. 

  913.                         String bigValueFilePath(bigValueFilePathTry);

  914. 

  915. #ifdef CARLA_OS_WIN

  916.                         // check if running under Wine

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

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

  919. #endif

  920. 

  921.                         File bigValueFile(bigValueFilePath);

  922.                         CARLA_SAFE_ASSERT_BREAK(bigValueFile.existsAsFile());

  923. 

  924.                         plugin->setCustomData(typeStr, keyStr, bigValueFile.loadFileAsString().toRawUTF8(), true);

  925. 

  926.                         bigValueFile.deleteFile();

  927.                     }

  928.                     else

  929.                     {

  930.                         char valueStr[valueSize+1];

  931.                         carla_zeroChars(valueStr, valueSize+1);

  932.                         fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  933. 

  934.                         if (plugin->isEnabled())

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

  936.                     }

  937.                 }

  938.                 else

  939.                 {

  940.                     if (plugin->isEnabled())

  941.                         plugin->setCustomData(typeStr, keyStr, "", true);

  942.                 }

  943. 

  944.                 break;

  945.             }

  946. 

  947.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  949.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  950. 

  951.                 char chunkFilePathTry[size+1];

  952.                 carla_zeroChars(chunkFilePathTry, size+1);

  953.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  954. 

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

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

  957. 

  958.                 String chunkFilePath(chunkFilePathTry);

  959. 

  960. #ifdef CARLA_OS_WIN

  961.                 // check if running under Wine

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

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

  964. #endif

  965. 

  966.                 File chunkFile(chunkFilePath);

  967.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  968. 

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

  970.                 chunkFile.deleteFile();

  971.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  972. 

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

  974. 

  975. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  977. #else

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

  979. #endif

  980.                 break;

  981.             }

  982. 

  983.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  986. 

  987.                 if (plugin->isEnabled())

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

  989.                 break;

  990.             }

  991. 

  992.             case kPluginBridgeNonRtClientSetOption: {

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

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

  995. 

  996.                 if (plugin->isEnabled())

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

  998.                 break;

  999.             }

  1000. 

  1001.             case kPluginBridgeNonRtClientSetOptions: {

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

  1003. 

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

  1005.                 break;

  1006.             }

  1007. 

  1008.             case kPluginBridgeNonRtClientSetWindowTitle: {

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

  1010.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  1011. 

  1012.                 char title[size+1];

  1013.                 carla_zeroChars(title, size+1);

  1014.                 fShmNonRtClientControl.readCustomData(title, size);

  1015. 

  1016.                 plugin->setCustomUITitle(title);

  1017.                 break;

  1018.             }

  1019. 

  1020.             case kPluginBridgeNonRtClientGetParameterText: {

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

  1022. 

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

  1024.                 {

  1025.                     char bufStr[STR_MAX+1];

  1026.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  1029. 

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

  1031. 

  1032.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1033. 

  1034.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1035. 

  1036.                     fShmNonRtServerControl.writeInt(index);

  1037.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  1038.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  1039.                     fShmNonRtServerControl.commitWrite();

  1040. 

  1041.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1042.                 }

  1043.                 else

  1044.                 {

  1045.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1046. 

  1047.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1048.                     fShmNonRtServerControl.writeInt(index);

  1049.                     fShmNonRtServerControl.writeUInt(0);

  1050.                     fShmNonRtServerControl.commitWrite();

  1051.                 }

  1052. 

  1053.                 break;

  1054.             }

  1055. 

  1056.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1058.                 {

  1059.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1060.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1061.                     fShmNonRtServerControl.commitWrite();

  1062.                     return;

  1063.                 }

  1064. 

  1065.                 plugin->prepareForSave(false);

  1066. 

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

  1068. 

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

  1070.                 {

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

  1072. 

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

  1074.                         continue;

  1075. 

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

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

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

  1079. 

  1080.                     {

  1081.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1082. 

  1083.                         if (valueLen > maxLocalValueLen)

  1084.                             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1085. 

  1086.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1087. 

  1088.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1090. 

  1091.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1093. 

  1094.                         fShmNonRtServerControl.writeUInt(valueLen);

  1095. 

  1096.                         if (valueLen > 0)

  1097.                         {

  1098.                             if (valueLen > maxLocalValueLen)

  1099.                             {

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

  1101. 

  1102.                                 filePath += CARLA_OS_SEP_STR ".CarlaCustomData_";

  1103.                                 filePath += fShmAudioPool.getFilenameSuffix();

  1104. 

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

  1106.                                 {

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

  1108. 

  1109.                                     fShmNonRtServerControl.writeUInt(ulength);

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

  1111.                                 }

  1112.                                 else

  1113.                                 {

  1114.                                     fShmNonRtServerControl.writeUInt(0);

  1115.                                 }

  1116.                             }

  1117.                             else

  1118.                             {

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

  1120.                             }

  1121.                         }

  1122. 

  1123.                         fShmNonRtServerControl.commitWrite();

  1124.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1125.                     }

  1126.                 }

  1127. 

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

  1129.                 {

  1130.                     void* data = nullptr;

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

  1132.                     {

  1133.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1134. 

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

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

  1137. 

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

  1139. 

  1140.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1141.                         filePath += fShmAudioPool.getFilenameSuffix();

  1142. 

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

  1144.                         {

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

  1146. 

  1147.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1148. 

  1149.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1150.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1152.                             fShmNonRtServerControl.commitWrite();

  1153.                         }

  1154.                     }

  1155.                 }

  1156. 

  1157.                 {

  1158.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1159. 

  1160.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1161.                     fShmNonRtServerControl.commitWrite();

  1162.                 }

  1163.                 break;

  1164.             }

  1165. 

  1166.             case kPluginBridgeNonRtClientRestoreLV2State:

  1167.                 if (plugin->isEnabled())

  1168.                     plugin->restoreLV2State(false);

  1169.                 break;

  1170. 

  1171.             case kPluginBridgeNonRtClientShowUI:

  1172.                 if (plugin->isEnabled())

  1173.                     plugin->showCustomUI(true);

  1174.                 break;

  1175. 

  1176.             case kPluginBridgeNonRtClientHideUI:

  1177.                 if (plugin->isEnabled())

  1178.                     plugin->showCustomUI(false);

  1179.                 break;

  1180. 

  1181.             case kPluginBridgeNonRtClientEmbedUI: {

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

  1183.                 uint64_t resp = 0;

  1184. 

  1185.                 if (plugin->isEnabled())

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

  1187. 

  1188.                 if (resp == 0)

  1189.                     resp = 1;

  1190. 

  1191.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1192. 

  1193.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerRespEmbedUI);

  1194.                 fShmNonRtServerControl.writeULong(reinterpret_cast<uint64_t>(resp));

  1195.                 fShmNonRtServerControl.commitWrite();

  1196.                 break;

  1197.             }

  1198. 

  1199.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1202. 

  1203.                 if (plugin->isEnabled())

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

  1205.                 break;

  1206.             }

  1207. 

  1208.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1210. 

  1211.                 if (plugin->isEnabled())

  1212.                     plugin->uiProgramChange(index);

  1213.                 break;

  1214.             }

  1215. 

  1216.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1218. 

  1219.                 if (plugin->isEnabled())

  1220.                     plugin->uiMidiProgramChange(index);

  1221.                 break;

  1222.             }

  1223. 

  1224.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1228. 

  1229.                 if (plugin->isEnabled())

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

  1231.                 break;

  1232.             }

  1233. 

  1234.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1237. 

  1238.                 if (plugin->isEnabled())

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

  1240.                 break;

  1241.             }

  1242. 

  1243.             case kPluginBridgeNonRtClientQuit:

  1244.                 fClosingDown = true;

  1245.                 signalThreadShouldExit();

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

  1247.                 break;

  1248. 

  1249.             case kPluginBridgeNonRtClientReload:

  1250.                 fFirstIdle = true;

  1251.                 break;

  1252.             }

  1253.         }

  1254.     }

  1255. 

  1256.     // -------------------------------------------------------------------

  1257. 

  1258. protected:

  1259.     void run() override

  1260.     {

  1261. #ifdef __SSE2_MATH__

  1262.         // Set FTZ and DAZ flags

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

  1264. #endif

  1265. 

  1266.         bool quitReceived = false;

  1267. 

  1268.         for (; ! shouldThreadExit();)

  1269.         {

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

  1271. 

  1272.             if (! helper.ok)

  1273.                 continue;

  1274. 

  1275.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1276.             {

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

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

  1279. 

  1280. #ifdef DEBUG

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

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

  1283.                 }

  1284. #endif

  1285. 

  1286.                 switch (opcode)

  1287.                 {

  1288.                 case kPluginBridgeRtClientNull:

  1289.                     break;

  1290. 

  1291.                 case kPluginBridgeRtClientSetAudioPool: {

  1292.                     if (fShmAudioPool.data != nullptr)

  1293.                     {

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

  1295.                         fShmAudioPool.data = nullptr;

  1296.                     }

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

  1298.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1300.                     break;

  1301.                 }

  1302. 

  1303.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1305.                     pData->bufferSize = bufferSize;

  1306.                     bufferSizeChanged(bufferSize);

  1307.                     break;

  1308.                 }

  1309. 

  1310.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1312.                     pData->sampleRate = sampleRate;

  1313.                     sampleRateChanged(sampleRate);

  1314.                     break;

  1315.                 }

  1316. 

  1317.                 case kPluginBridgeRtClientSetOnline:

  1318.                     fIsOffline = fShmRtClientControl.readBool();

  1319.                     offlineModeChanged(fIsOffline);

  1320.                     break;

  1321. 

  1322.                 // NOTE this is never used

  1323.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1328. 

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

  1330.                     {

  1331.                         event->type                 = kEngineEventTypeControl;

  1332.                         event->time                 = time;

  1333.                         event->channel              = channel;

  1334.                         event->ctrl.type            = kEngineControlEventTypeParameter;

  1335.                         event->ctrl.param           = param;

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

  1337.                         event->ctrl.normalizedValue = value;

  1338.                         event->ctrl.handled         = true;

  1339.                     }

  1340.                     break;

  1341.                 }

  1342. 

  1343.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1347. 

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

  1349.                     {

  1350.                         event->type                 = kEngineEventTypeControl;

  1351.                         event->time                 = time;

  1352.                         event->channel              = channel;

  1353.                         event->ctrl.type            = kEngineControlEventTypeMidiBank;

  1354.                         event->ctrl.param           = index;

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

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

  1357.                         event->ctrl.handled         = true;

  1358.                     }

  1359.                     break;

  1360.                 }

  1361. 

  1362.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1366. 

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

  1368.                     {

  1369.                         event->type                 = kEngineEventTypeControl;

  1370.                         event->time                 = time;

  1371.                         event->channel              = channel;

  1372.                         event->ctrl.type            = kEngineControlEventTypeMidiProgram;

  1373.                         event->ctrl.param           = index;

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

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

  1376.                         event->ctrl.handled         = true;

  1377.                     }

  1378.                     break;

  1379.                 }

  1380. 

  1381.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1384. 

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

  1386.                     {

  1387.                         event->type                 = kEngineEventTypeControl;

  1388.                         event->time                 = time;

  1389.                         event->channel              = channel;

  1390.                         event->ctrl.type            = kEngineControlEventTypeAllSoundOff;

  1391.                         event->ctrl.param           = 0;

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

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

  1394.                         event->ctrl.handled         = true;

  1395.                     }

  1396.                 }   break;

  1397. 

  1398.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1401. 

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

  1403.                     {

  1404.                         event->type                 = kEngineEventTypeControl;

  1405.                         event->time                 = time;

  1406.                         event->channel              = channel;

  1407.                         event->ctrl.type            = kEngineControlEventTypeAllNotesOff;

  1408.                         event->ctrl.param           = 0;

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

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

  1411.                         event->ctrl.handled         = true;

  1412.                     }

  1413.                 }   break;

  1414. 

  1415.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1419.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1420. 

  1421.                     // FIXME variable-size stack

  1422.                     uint8_t data[size];

  1423. 

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

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

  1426. 

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

  1428.                     {

  1429.                         event->type    = kEngineEventTypeMidi;

  1430.                         event->time    = time;

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

  1432. 

  1433.                         event->midi.port = port;

  1434.                         event->midi.size = size;

  1435. 

  1436.                         if (size > EngineMidiEvent::kDataSize)

  1437.                         {

  1438.                             event->midi.dataExt = data;

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

  1440.                         }

  1441.                         else

  1442.                         {

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

  1444. 

  1445.                             uint8_t i=1;

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

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

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

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

  1450. 

  1451.                             event->midi.dataExt = nullptr;

  1452.                         }

  1453.                     }

  1454.                     break;

  1455.                 }

  1456. 

  1457.                 case kPluginBridgeRtClientProcess: {

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

  1459. 

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

  1461. 

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

  1463.                     {

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

  1465. 

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

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

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

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

  1470. 

  1471.                         const float* audioIn[audioInCount];

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

  1473.                         const float* cvIn[cvInCount];

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

  1475. 

  1476.                         float* fdata = fShmAudioPool.data;

  1477. 

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

  1479.                             audioIn[i] = fdata;

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

  1481.                             audioOut[i] = fdata;

  1482. 

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

  1484.                             cvIn[i] = fdata;

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

  1486.                             cvOut[i] = fdata;

  1487. 

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

  1489. 

  1490.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1491.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1492.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1494. 

  1495.                         if (timeInfo.bbt.valid)

  1496.                         {

  1497.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1498.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1499.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1500. 

  1501.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1502.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1503. 

  1504.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1505.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1506.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1507.                         }

  1508. 

  1509.                         plugin->initBuffers();

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

  1511.                         plugin->unlock();

  1512.                     }

  1513. 

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

  1515.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1516.                     std::size_t curMidiDataPos = 0;

  1517. 

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

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

  1520. 

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

  1522.                     {

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

  1524.                         {

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

  1526. 

  1527.                             if (event.type == kEngineEventTypeNull)

  1528.                                 break;

  1529. 

  1530.                             if (event.type == kEngineEventTypeControl)

  1531.                             {

  1532.                                 uint8_t data[3];

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

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

  1535. 

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

  1537.                                     break;

  1538. 

  1539.                                 // set time

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

  1541.                                 midiData = midiData + 4;

  1542.                                 curMidiDataPos += 4;

  1543. 

  1544.                                 // set port

  1545.                                 *midiData++ = 0;

  1546.                                 ++curMidiDataPos;

  1547. 

  1548.                                 // set size

  1549.                                 *midiData++ = size;

  1550.                                 ++curMidiDataPos;

  1551. 

  1552.                                 // set data

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

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

  1555. 

  1556.                                 curMidiDataPos += size;

  1557.                             }

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

  1559.                             {

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

  1561. 

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

  1563.                                     break;

  1564. 

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

  1566. 

  1567.                                 // set time

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

  1569.                                 midiData += 4;

  1570.                                 curMidiDataPos += 4;

  1571. 

  1572.                                 // set port

  1573.                                 *midiData++ = _midiEvent.port;

  1574.                                 ++curMidiDataPos;

  1575. 

  1576.                                 // set size

  1577.                                 *midiData++ = _midiEvent.size;

  1578.                                 ++curMidiDataPos;

  1579. 

  1580.                                 // set data

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

  1582. 

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

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

  1585. 

  1586.                                 curMidiDataPos += _midiEvent.size;

  1587.                             }

  1588.                         }

  1589. 

  1590.                         if (curMidiDataPos != 0 &&

  1591.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1592.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1593. 

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

  1595.                     }

  1596. 

  1597.                 }   break;

  1598. 

  1599.                 case kPluginBridgeRtClientQuit: {

  1600.                     quitReceived = true;

  1601.                     fClosingDown = true;

  1602.                     signalThreadShouldExit();

  1603.                 }   break;

  1604.                 }

  1605.             }

  1606.         }

  1607. 

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

  1609. 

  1610.         if (! quitReceived)

  1611.         {

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

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

  1614. 

  1615.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1616.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1617.             fShmNonRtServerControl.writeUInt(messageSize);

  1618.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1619.             fShmNonRtServerControl.commitWrite();

  1620.         }

  1621.     }

  1622. 

  1623.     // called from process thread above

  1624.     EngineEvent* getNextFreeInputEvent() const noexcept

  1625.     {

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

  1627.         {

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

  1629. 

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

  1631.                 return event;

  1632.         }

  1633.         return nullptr;

  1634.     }

  1635. 

  1636.     void latencyChanged(const uint32_t samples) noexcept override

  1637.     {

  1638.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1639. 

  1640.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1641.         fShmNonRtServerControl.writeUInt(samples);

  1642.         fShmNonRtServerControl.commitWrite();

  1643.     }

  1644. 

  1645.     // -------------------------------------------------------------------

  1646. 

  1647. private:

  1648.     BridgeAudioPool          fShmAudioPool;

  1649.     BridgeRtClientControl    fShmRtClientControl;

  1650.     BridgeNonRtClientControl fShmNonRtClientControl;

  1651.     BridgeNonRtServerControl fShmNonRtServerControl;

  1652. 

  1653.     CarlaString fBaseNameAudioPool;

  1654.     CarlaString fBaseNameRtClientControl;

  1655.     CarlaString fBaseNameNonRtClientControl;

  1656.     CarlaString fBaseNameNonRtServerControl;

  1657. 

  1658.     bool fClosingDown;

  1659.     bool fIsOffline;

  1660.     bool fFirstIdle;

  1661.     uint32_t fBridgeVersion;

  1662.     int64_t fLastPingTime;

  1663. 

  1664.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1665. };

  1666. 

  1667. // -----------------------------------------------------------------------

  1668. 

  1669. namespace EngineInit {

  1670. 

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

  1672.                        const char* const rtClientBaseName,

  1673.                        const char* const nonRtClientBaseName,

  1674.                        const char* const nonRtServerBaseName)

  1675. {

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

  1677. }

  1678. 

  1679. }

  1680. 

  1681. // -----------------------------------------------------------------------

  1682. 

  1683. CARLA_BACKEND_END_NAMESPACE

  1684. 

  1685. // -----------------------------------------------------------------------

  1686. 

  1687. #include "CarlaBridgeUtils.cpp"

  1688. 

  1689. // -----------------------------------------------------------------------