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

1720 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 "CarlaTimeUtils.hpp"

  36. #include "CarlaMIDI.h"

  37. 

  38. #ifdef __SSE2_MATH__

  39. # include <xmmintrin.h>

  40. #endif

  41. 

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

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

  44. 

  45. // must be last

  46. #include "jackbridge/JackBridge.hpp"

  47. 

  48. using water::File;

  49. using water::MemoryBlock;

  50. using water::String;

  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.           fBridgeVersion(0),

  151.           fLastPingTime(-1)

  152.     {

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

  154.     }

  155. 

  156.     ~CarlaEngineBridge() noexcept override

  157.     {

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

  159. 

  160.         clear();

  161.     }

  162. 

  163.     // -------------------------------------

  164.     // CarlaEngine virtual calls

  165. 

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

  167.     {

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

  169. 

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

  171.         {

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

  173.             return false;

  174.         }

  175. 

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

  177.         {

  178.             pData->close();

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

  180.             return false;

  181.         }

  182. 

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

  184.         {

  185.             pData->close();

  186.             clear();

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

  188.             return false;

  189.         }

  190. 

  191.         if (! fShmRtClientControl.mapData())

  192.         {

  193.             pData->close();

  194.             clear();

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

  196.             return false;

  197.         }

  198. 

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

  200.         {

  201.             pData->close();

  202.             clear();

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

  204.             return false;

  205.         }

  206. 

  207.         if (! fShmNonRtClientControl.mapData())

  208.         {

  209.             pData->close();

  210.             clear();

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

  212.             return false;

  213.         }

  214. 

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

  216.         {

  217.             pData->close();

  218.             clear();

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

  220.             return false;

  221.         }

  222. 

  223.         if (! fShmNonRtServerControl.mapData())

  224.         {

  225.             pData->close();

  226.             clear();

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

  228.             return false;

  229.         }

  230. 

  231.         PluginBridgeNonRtClientOpcode opcode;

  232. 

  233.         opcode = fShmNonRtClientControl.readOpcode();

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

  235. 

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

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

  238. 

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

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

  241. 

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

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

  244. 

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

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

  247. 

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

  249.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  250.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  251.         {

  252.             pData->close();

  253.             clear();

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

  255.             return false;

  256.         }

  257. 

  258.         opcode = fShmNonRtClientControl.readOpcode();

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

  260. 

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

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

  263. 

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

  265.         {

  266.             pData->close();

  267.             clear();

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

  269.             return false;

  270.         }

  271. 

  272.         pData->initTime(nullptr);

  273. 

  274.         // tell backend we're live

  275.         {

  276.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  277. 

  278.             // kPluginBridgeNonRtServerVersion was added in API 7

  279.             if (apiVersion >= 7)

  280.             {

  281.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  282.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  283.             }

  284.             else

  285.             {

  286.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  287.             }

  288. 

  289.             fShmNonRtServerControl.commitWrite();

  290.         }

  291. 

  292.         startThread(true);

  293.         return true;

  294.     }

  295. 

  296.     bool close() override

  297.     {

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

  299.         fLastPingTime = -1;

  300. 

  301.         CarlaEngine::close();

  302. 

  303.         stopThread(5000);

  304.         clear();

  305. 

  306.         return true;

  307.     }

  308. 

  309.     bool hasIdleOnMainThread() const noexcept override

  310.     {

  311.         return true;

  312.     }

  313. 

  314.     bool isRunning() const noexcept override

  315.     {

  316.         if (fClosingDown)

  317.             return false;

  318. 

  319.         return isThreadRunning() || ! fFirstIdle;

  320.     }

  321. 

  322.     bool isOffline() const noexcept override

  323.     {

  324.         return fIsOffline;

  325.     }

  326. 

  327.     EngineType getType() const noexcept override

  328.     {

  329.         return kEngineTypeBridge;

  330.     }

  331. 

  332.     const char* getCurrentDriverName() const noexcept override

  333.     {

  334.         return "Bridge";

  335.     }

  336. 

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

  338.     {

  339.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  340. 

  341.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  342.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  343.         fShmNonRtServerControl.writeUInt(parameterId);

  344.         fShmNonRtServerControl.writeBool(touch);

  345.         fShmNonRtServerControl.commitWrite();

  346.     }

  347. 

  348.     CarlaEngineClient* addClient(const CarlaPluginPtr plugin) override

  349.     {

  350. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  352. #else

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

  354. 

  355.         // unused

  356.         (void)plugin;

  357. #endif

  358.     }

  359. 

  360.     void idle() noexcept override

  361.     {

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

  363. 

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

  365.         {

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

  367.             {

  368.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  369.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  370.                 fShmNonRtServerControl.writeUInt(length);

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

  372.                 fShmNonRtServerControl.commitWrite();

  373.             }

  374. 

  375.             signalThreadShouldExit();

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

  377.             return;

  378.         }

  379. 

  380.         const bool wasFirstIdle = fFirstIdle;

  381. 

  382.         if (wasFirstIdle)

  383.         {

  384.             fFirstIdle = false;

  385.             fLastPingTime = carla_gettime_ms();

  386.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  387. 

  388.             char bufStr[STR_MAX+1];

  389.             carla_zeroChars(bufStr, STR_MAX+1);

  390. 

  391.             uint32_t bufStrSize;

  392. 

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

  394.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  395. 

  396.             // kPluginBridgeNonRtServerPluginInfo1

  397.             {

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

  399.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  405.                 fShmNonRtServerControl.commitWrite();

  406.             }

  407. 

  408.             // kPluginBridgeNonRtServerPluginInfo2

  409.             {

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

  411.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  412. 

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

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

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

  416.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  417.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  418. 

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

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

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

  422.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  423.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  424. 

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

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

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

  428.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  429.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  430. 

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

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

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

  434.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  435.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  436. 

  437.                 fShmNonRtServerControl.commitWrite();

  438.             }

  439. 

  440.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  441. 

  442.             // kPluginBridgeNonRtServerAudioCount

  443.             {

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

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

  446. 

  447.                 // uint/ins, uint/outs

  448.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  449.                 fShmNonRtServerControl.writeUInt(aIns);

  450.                 fShmNonRtServerControl.writeUInt(aOuts);

  451.                 fShmNonRtServerControl.commitWrite();

  452. 

  453.                 // kPluginBridgeNonRtServerPortName

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

  455.                 {

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

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

  458. 

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

  460.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  461.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  462.                     fShmNonRtServerControl.writeUInt(i);

  463. 

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

  465.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  466.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  467.                 }

  468. 

  469.                 // kPluginBridgeNonRtServerPortName

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

  471.                 {

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

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

  474. 

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

  476.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  477.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  478.                     fShmNonRtServerControl.writeUInt(i);

  479. 

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

  481.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  482.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  483.                 }

  484.             }

  485. 

  486.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  487. 

  488.             // kPluginBridgeNonRtServerMidiCount

  489.             {

  490.                 // uint/ins, uint/outs

  491.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  494.                 fShmNonRtServerControl.commitWrite();

  495.             }

  496. 

  497.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  498. 

  499.             // kPluginBridgeNonRtServerCvCount

  500.             {

  501.                 // uint/ins, uint/outs

  502.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  505.                 fShmNonRtServerControl.commitWrite();

  506.             }

  507. 

  508.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  509. 

  510.             // kPluginBridgeNonRtServerParameter*

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

  512.             {

  513.                 // uint/count

  514.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  515.                 fShmNonRtServerControl.writeUInt(count);

  516.                 fShmNonRtServerControl.commitWrite();

  517. 

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

  519.                 {

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

  521. 

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

  523.                         continue;

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

  525.                         continue;

  526. 

  527.                     // kPluginBridgeNonRtServerParameterData1

  528.                     {

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

  530.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  531.                         fShmNonRtServerControl.writeUInt(i);

  532.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  533.                         fShmNonRtServerControl.writeUInt(paramData.type);

  534.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  535.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  536.                         fShmNonRtServerControl.commitWrite();

  537.                     }

  538. 

  539.                     // kPluginBridgeNonRtServerParameterData2

  540.                     {

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

  542.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  543.                         fShmNonRtServerControl.writeUInt(i);

  544. 

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

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

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

  548.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  549.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  550. 

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

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

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

  554.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  555.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  556. 

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

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

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

  560.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  561.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  562. 

  563.                         fShmNonRtServerControl.commitWrite();

  564.                     }

  565. 

  566.                     // kPluginBridgeNonRtServerParameterRanges

  567.                     {

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

  569. 

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

  571.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  572.                         fShmNonRtServerControl.writeUInt(i);

  573.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  574.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  575.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  576.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  577.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  578.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  579.                         fShmNonRtServerControl.commitWrite();

  580.                     }

  581. 

  582.                     // kPluginBridgeNonRtServerParameterValue2

  583.                     {

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

  585.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  586.                         fShmNonRtServerControl.writeUInt(i);

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

  588.                         fShmNonRtServerControl.commitWrite();

  589.                     }

  590. 

  591.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  592.                 }

  593.             }

  594. 

  595.             // kPluginBridgeNonRtServerProgram*

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

  597.             {

  598.                 // uint/count

  599.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  600.                 fShmNonRtServerControl.writeUInt(count);

  601.                 fShmNonRtServerControl.commitWrite();

  602. 

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

  604.                 {

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

  606.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  607.                     fShmNonRtServerControl.writeUInt(i);

  608. 

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

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

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

  612.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  613.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  614. 

  615.                     fShmNonRtServerControl.commitWrite();

  616.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  617.                 }

  618.             }

  619. 

  620.             // kPluginBridgeNonRtServerMidiProgram*

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

  622.             {

  623.                 // uint/count

  624.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  625.                 fShmNonRtServerControl.writeUInt(count);

  626.                 fShmNonRtServerControl.commitWrite();

  627. 

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

  629.                 {

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

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

  632. 

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

  634.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  635.                     fShmNonRtServerControl.writeUInt(i);

  636.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  637.                     fShmNonRtServerControl.writeUInt(mpData.program);

  638. 

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

  640.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  642. 

  643.                     fShmNonRtServerControl.commitWrite();

  644.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  645.                 }

  646.             }

  647. 

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

  649.             {

  650.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  651.                 fShmNonRtServerControl.writeUInt(latency);

  652.                 fShmNonRtServerControl.commitWrite();

  653.             }

  654. 

  655.             // ready!

  656.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  657.             fShmNonRtServerControl.commitWrite();

  658.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  659. 

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

  661.             fLastPingTime = carla_gettime_ms();

  662.         }

  663. 

  664.         // send parameter outputs

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

  666.         {

  667.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  668. 

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

  670.             {

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

  672.                     continue;

  673. 

  674.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  675.                 fShmNonRtServerControl.writeUInt(i);

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

  677. 

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

  679.                 if (! fShmNonRtServerControl.commitWrite())

  680.                     break;

  681.             }

  682.         }

  683. 

  684.         CarlaEngine::idle();

  685. 

  686.         try {

  687.             handleNonRtData();

  688.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  689. 

  690.         if (fLastPingTime > 0 && carla_gettime_ms() > fLastPingTime + 30000 && ! wasFirstIdle)

  691.         {

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

  693.             signalThreadShouldExit();

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

  695.         }

  696.     }

  697. 

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

  699.                   const EngineCallbackOpcode action, const uint pluginId,

  700.                   const int value1, const int value2, const int value3,

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

  702.     {

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

  704. 

  705.         if (fClosingDown || ! sendHost)

  706.             return;

  707. 

  708.         switch (action)

  709.         {

  710.         // uint/index float/value

  711.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  712.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  713.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  714.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  716.             fShmNonRtServerControl.writeFloat(valuef);

  717.             fShmNonRtServerControl.commitWrite();

  718.         }   break;

  719. 

  720.         // uint/index float/value

  721.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  722.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  723.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  724.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  726.             fShmNonRtServerControl.writeFloat(valuef);

  727.             fShmNonRtServerControl.commitWrite();

  728.         }   break;

  729. 

  730.         // int/index

  731.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  732.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  733.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  734.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  735.             fShmNonRtServerControl.writeInt(value1);

  736.             fShmNonRtServerControl.commitWrite();

  737.         }   break;

  738. 

  739.         // int/index

  740.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  741.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  742.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  743.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  744.             fShmNonRtServerControl.writeInt(value1);

  745.             fShmNonRtServerControl.commitWrite();

  746.         }   break;

  747. 

  748.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  749.             if (value1 != 1)

  750.             {

  751.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  752.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  753.                 fShmNonRtServerControl.commitWrite();

  754.             }

  755.             break;

  756. 

  757.         case ENGINE_CALLBACK_EMBED_UI_RESIZED: {

  758.             CARLA_SAFE_ASSERT_BREAK(value1 > 1);

  759.             CARLA_SAFE_ASSERT_BREAK(value2 > 1);

  760. 

  761.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  762. 

  763.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerResizeEmbedUI);

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

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

  766.             fShmNonRtServerControl.commitWrite();

  767.         }   break;

  768. 

  769.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

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

  771.             {

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

  773.                 {

  774.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  775. 

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

  777.                     {

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

  779. 

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

  781.                             continue;

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

  783.                             continue;

  784. 

  785.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  786.                         fShmNonRtServerControl.writeUInt(i);

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

  788.                         fShmNonRtServerControl.commitWrite();

  789. 

  790.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  791.                     }

  792.                 }

  793.             }

  794.             break;

  795. 

  796.         default:

  797.             break;

  798.         }

  799.     }

  800. 

  801.     // -------------------------------------------------------------------

  802. 

  803.     void clear() noexcept

  804.     {

  805.         fShmAudioPool.clear();

  806.         fShmRtClientControl.clear();

  807.         fShmNonRtClientControl.clear();

  808.         fShmNonRtServerControl.clear();

  809.     }

  810. 

  811.     void handleNonRtData()

  812.     {

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

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

  815. 

  816.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  817.         {

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

  819. 

  820. #ifdef DEBUG

  821.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  823.                             opcode, PluginBridgeNonRtClientOpcode2str(opcode));

  824.             }

  825. #endif

  826. 

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

  828.                 fLastPingTime = carla_gettime_ms();

  829. 

  830.             switch (opcode)

  831.             {

  832.             case kPluginBridgeNonRtClientNull:

  833.                 break;

  834. 

  835.             case kPluginBridgeNonRtClientVersion: {

  836.                 fBridgeVersion = fShmNonRtServerControl.readUInt();

  837.                 CARLA_SAFE_ASSERT_UINT2(fBridgeVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  838.                                         fBridgeVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  839.             }   break;

  840. 

  841.             case kPluginBridgeNonRtClientPing: {

  842.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  843. 

  844.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  845.                 fShmNonRtServerControl.commitWrite();

  846.             }   break;

  847. 

  848.             case kPluginBridgeNonRtClientPingOnOff: {

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

  850. 

  851.                 fLastPingTime = onOff ? carla_gettime_ms() : -1;

  852.             }   break;

  853. 

  854.             case kPluginBridgeNonRtClientActivate:

  855.                 if (plugin->isEnabled())

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

  857.                 break;

  858. 

  859.             case kPluginBridgeNonRtClientDeactivate:

  860.                 if (plugin->isEnabled())

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

  862.                 break;

  863. 

  864.             case kPluginBridgeNonRtClientInitialSetup:

  865.                 // should never happen!!

  866.                 fShmNonRtServerControl.readUInt();

  867.                 fShmNonRtServerControl.readDouble();

  868.                 break;

  869. 

  870.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  873. 

  874.                 if (plugin->isEnabled())

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

  876.                 break;

  877.             }

  878. 

  879.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  882. 

  883.                 if (plugin->isEnabled())

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

  885.                 break;

  886.             }

  887. 

  888.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

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

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

  891. 

  892.                 if (plugin->isEnabled())

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

  894.                 break;

  895.             }

  896. 

  897.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  901. 

  902.                 if (plugin->isEnabled())

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

  904.                 break;

  905.             }

  906. 

  907.             case kPluginBridgeNonRtClientSetProgram: {

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

  909. 

  910.                 if (plugin->isEnabled())

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

  912.                 break;

  913.             }

  914. 

  915.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  917. 

  918.                 if (plugin->isEnabled())

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

  920.                 break;

  921.             }

  922. 

  923.             case kPluginBridgeNonRtClientSetCustomData: {

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

  925. 

  926.                 // type

  927.                 const BridgeTextReader type(fShmNonRtClientControl);

  928. 

  929.                 // key

  930.                 const BridgeTextReader key(fShmNonRtClientControl);

  931. 

  932.                 // value

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

  934. 

  935.                 if (valueSize > 0)

  936.                 {

  937.                     if (valueSize > maxLocalValueLen)

  938.                     {

  939.                         const BridgeTextReader bigValueFilePathTry(fShmNonRtClientControl, valueSize);

  940. 

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

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

  943. 

  944.                         String bigValueFilePath(bigValueFilePathTry.text);

  945. 

  946. #ifdef CARLA_OS_WIN

  947.                         // check if running under Wine

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

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

  950. #endif

  951. 

  952.                         File bigValueFile(bigValueFilePath);

  953.                         CARLA_SAFE_ASSERT_BREAK(bigValueFile.existsAsFile());

  954. 

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

  956. 

  957.                         bigValueFile.deleteFile();

  958.                     }

  959.                     else

  960.                     {

  961.                         const BridgeTextReader value(fShmNonRtClientControl, valueSize);

  962. 

  963.                         if (plugin->isEnabled())

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

  965.                     }

  966.                 }

  967.                 else

  968.                 {

  969.                     if (plugin->isEnabled())

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

  971.                 }

  972. 

  973.                 break;

  974.             }

  975. 

  976.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  978.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  979. 

  980.                 const BridgeTextReader chunkFilePathTry(fShmNonRtClientControl, size);

  981. 

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

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

  984. 

  985.                 String chunkFilePath(chunkFilePathTry.text);

  986. 

  987. #ifdef CARLA_OS_WIN

  988.                 // check if running under Wine

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

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

  991. #endif

  992. 

  993.                 File chunkFile(chunkFilePath);

  994.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  995. 

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

  997.                 chunkFile.deleteFile();

  998.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  999. 

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

  1001. 

  1002. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  1004. #else

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

  1006. #endif

  1007.                 break;

  1008.             }

  1009. 

  1010.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  1013. 

  1014.                 if (plugin->isEnabled())

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

  1016.                 break;

  1017.             }

  1018. 

  1019.             case kPluginBridgeNonRtClientSetOption: {

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

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

  1022. 

  1023.                 if (plugin->isEnabled())

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

  1025.                 break;

  1026.             }

  1027. 

  1028.             case kPluginBridgeNonRtClientSetOptions: {

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

  1030. 

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

  1032.                 break;

  1033.             }

  1034. 

  1035.             case kPluginBridgeNonRtClientSetWindowTitle: {

  1036.                 const BridgeTextReader title(fShmNonRtClientControl);

  1037. 

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

  1039.                 break;

  1040.             }

  1041. 

  1042.             case kPluginBridgeNonRtClientGetParameterText: {

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

  1044. 

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

  1046.                 {

  1047.                     char bufStr[STR_MAX+1];

  1048.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  1051. 

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

  1053. 

  1054.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1055. 

  1056.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1057. 

  1058.                     fShmNonRtServerControl.writeInt(index);

  1059.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  1060.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  1061.                     fShmNonRtServerControl.commitWrite();

  1062. 

  1063.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1064.                 }

  1065.                 else

  1066.                 {

  1067.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1068. 

  1069.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1070.                     fShmNonRtServerControl.writeInt(index);

  1071.                     fShmNonRtServerControl.writeUInt(0);

  1072.                     fShmNonRtServerControl.commitWrite();

  1073.                 }

  1074. 

  1075.                 break;

  1076.             }

  1077. 

  1078.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1080.                 {

  1081.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1082.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1083.                     fShmNonRtServerControl.commitWrite();

  1084.                     return;

  1085.                 }

  1086. 

  1087.                 plugin->prepareForSave(false);

  1088. 

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

  1090. 

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

  1092.                 {

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

  1094. 

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

  1096.                         continue;

  1097. 

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

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

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

  1101. 

  1102.                     {

  1103.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1104. 

  1105.                         if (valueLen > maxLocalValueLen)

  1106.                             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1107. 

  1108.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1109. 

  1110.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1112. 

  1113.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1115. 

  1116.                         fShmNonRtServerControl.writeUInt(valueLen);

  1117. 

  1118.                         if (valueLen > 0)

  1119.                         {

  1120.                             if (valueLen > maxLocalValueLen)

  1121.                             {

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

  1123. 

  1124.                                 filePath += CARLA_OS_SEP_STR ".CarlaCustomData_";

  1125.                                 filePath += fShmAudioPool.getFilenameSuffix();

  1126. 

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

  1128.                                 {

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

  1130. 

  1131.                                     fShmNonRtServerControl.writeUInt(ulength);

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

  1133.                                 }

  1134.                                 else

  1135.                                 {

  1136.                                     fShmNonRtServerControl.writeUInt(0);

  1137.                                 }

  1138.                             }

  1139.                             else

  1140.                             {

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

  1142.                             }

  1143.                         }

  1144. 

  1145.                         fShmNonRtServerControl.commitWrite();

  1146.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1147.                     }

  1148.                 }

  1149. 

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

  1151.                 {

  1152.                     void* data = nullptr;

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

  1154.                     {

  1155.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1156. 

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

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

  1159. 

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

  1161. 

  1162.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1163.                         filePath += fShmAudioPool.getFilenameSuffix();

  1164. 

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

  1166.                         {

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

  1168. 

  1169.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1170. 

  1171.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1172.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1174.                             fShmNonRtServerControl.commitWrite();

  1175.                         }

  1176.                     }

  1177.                 }

  1178. 

  1179.                 {

  1180.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1181. 

  1182.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1183.                     fShmNonRtServerControl.commitWrite();

  1184.                 }

  1185.                 break;

  1186.             }

  1187. 

  1188.             case kPluginBridgeNonRtClientRestoreLV2State:

  1189.                 if (plugin->isEnabled())

  1190.                     plugin->restoreLV2State(false);

  1191.                 break;

  1192. 

  1193.             case kPluginBridgeNonRtClientShowUI:

  1194.                 if (plugin->isEnabled())

  1195.                     plugin->showCustomUI(true);

  1196.                 break;

  1197. 

  1198.             case kPluginBridgeNonRtClientHideUI:

  1199.                 if (plugin->isEnabled())

  1200.                     plugin->showCustomUI(false);

  1201.                 break;

  1202. 

  1203.             case kPluginBridgeNonRtClientEmbedUI: {

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

  1205.                 uint64_t resp = 0;

  1206. 

  1207.                 if (plugin->isEnabled())

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

  1209. 

  1210.                 if (resp == 0)

  1211.                     resp = 1;

  1212. 

  1213.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1214. 

  1215.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerRespEmbedUI);

  1216.                 fShmNonRtServerControl.writeULong(resp);

  1217.                 fShmNonRtServerControl.commitWrite();

  1218.                 break;

  1219.             }

  1220. 

  1221.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1224. 

  1225.                 if (plugin->isEnabled())

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

  1227.                 break;

  1228.             }

  1229. 

  1230.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1232. 

  1233.                 if (plugin->isEnabled())

  1234.                     plugin->uiProgramChange(index);

  1235.                 break;

  1236.             }

  1237. 

  1238.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1240. 

  1241.                 if (plugin->isEnabled())

  1242.                     plugin->uiMidiProgramChange(index);

  1243.                 break;

  1244.             }

  1245. 

  1246.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1250. 

  1251.                 if (plugin->isEnabled())

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

  1253.                 break;

  1254.             }

  1255. 

  1256.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1259. 

  1260.                 if (plugin->isEnabled())

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

  1262.                 break;

  1263.             }

  1264. 

  1265.             case kPluginBridgeNonRtClientQuit:

  1266.                 fClosingDown = true;

  1267.                 signalThreadShouldExit();

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

  1269.                 break;

  1270. 

  1271.             case kPluginBridgeNonRtClientReload:

  1272.                 fFirstIdle = true;

  1273.                 break;

  1274.             }

  1275.         }

  1276.     }

  1277. 

  1278.     // -------------------------------------------------------------------

  1279. 

  1280. protected:

  1281.     void run() override

  1282.     {

  1283. #ifdef __SSE2_MATH__

  1284.         // Set FTZ and DAZ flags

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

  1286. #endif

  1287. 

  1288.         bool quitReceived = false;

  1289. 

  1290.         for (; ! shouldThreadExit();)

  1291.         {

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

  1293. 

  1294.             if (! helper.ok)

  1295.                 continue;

  1296. 

  1297.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1298.             {

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

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

  1301. 

  1302. #ifdef DEBUG

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

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

  1305.                 }

  1306. #endif

  1307. 

  1308.                 switch (opcode)

  1309.                 {

  1310.                 case kPluginBridgeRtClientNull:

  1311.                     break;

  1312. 

  1313.                 case kPluginBridgeRtClientSetAudioPool: {

  1314.                     if (fShmAudioPool.data != nullptr)

  1315.                     {

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

  1317.                         fShmAudioPool.data = nullptr;

  1318.                     }

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

  1320.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1322.                     break;

  1323.                 }

  1324. 

  1325.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1327.                     pData->bufferSize = bufferSize;

  1328.                     bufferSizeChanged(bufferSize);

  1329.                     break;

  1330.                 }

  1331. 

  1332.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1334.                     pData->sampleRate = sampleRate;

  1335.                     sampleRateChanged(sampleRate);

  1336.                     break;

  1337.                 }

  1338. 

  1339.                 case kPluginBridgeRtClientSetOnline:

  1340.                     fIsOffline = fShmRtClientControl.readBool();

  1341.                     offlineModeChanged(fIsOffline);

  1342.                     break;

  1343. 

  1344.                 // NOTE this is never used

  1345.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1350. 

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

  1352.                     {

  1353.                         event->type                 = kEngineEventTypeControl;

  1354.                         event->time                 = time;

  1355.                         event->channel              = channel;

  1356.                         event->ctrl.type            = kEngineControlEventTypeParameter;

  1357.                         event->ctrl.param           = param;

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

  1359.                         event->ctrl.normalizedValue = value;

  1360.                         event->ctrl.handled         = true;

  1361.                     }

  1362.                     break;

  1363.                 }

  1364. 

  1365.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1369. 

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

  1371.                     {

  1372.                         event->type                 = kEngineEventTypeControl;

  1373.                         event->time                 = time;

  1374.                         event->channel              = channel;

  1375.                         event->ctrl.type            = kEngineControlEventTypeMidiBank;

  1376.                         event->ctrl.param           = index;

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

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

  1379.                         event->ctrl.handled         = true;

  1380.                     }

  1381.                     break;

  1382.                 }

  1383. 

  1384.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1388. 

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

  1390.                     {

  1391.                         event->type                 = kEngineEventTypeControl;

  1392.                         event->time                 = time;

  1393.                         event->channel              = channel;

  1394.                         event->ctrl.type            = kEngineControlEventTypeMidiProgram;

  1395.                         event->ctrl.param           = index;

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

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

  1398.                         event->ctrl.handled         = true;

  1399.                     }

  1400.                     break;

  1401.                 }

  1402. 

  1403.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1406. 

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

  1408.                     {

  1409.                         event->type                 = kEngineEventTypeControl;

  1410.                         event->time                 = time;

  1411.                         event->channel              = channel;

  1412.                         event->ctrl.type            = kEngineControlEventTypeAllSoundOff;

  1413.                         event->ctrl.param           = 0;

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

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

  1416.                         event->ctrl.handled         = true;

  1417.                     }

  1418.                 }   break;

  1419. 

  1420.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1423. 

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

  1425.                     {

  1426.                         event->type                 = kEngineEventTypeControl;

  1427.                         event->time                 = time;

  1428.                         event->channel              = channel;

  1429.                         event->ctrl.type            = kEngineControlEventTypeAllNotesOff;

  1430.                         event->ctrl.param           = 0;

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

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

  1433.                         event->ctrl.handled         = true;

  1434.                     }

  1435.                 }   break;

  1436. 

  1437.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1441.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1442. 

  1443.                     // FIXME variable-size stack

  1444.                     uint8_t data[4];

  1445. 

  1446.                     {

  1447.                         uint8_t i=0;

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

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

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

  1451.                             fShmRtClientControl.readByte();

  1452.                     }

  1453. 

  1454.                     if (size > 4)

  1455.                         continue;

  1456. 

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

  1458.                     {

  1459.                         event->type    = kEngineEventTypeMidi;

  1460.                         event->time    = time;

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

  1462. 

  1463.                         event->midi.port = port;

  1464.                         event->midi.size = size;

  1465. 

  1466.                         if (size > EngineMidiEvent::kDataSize)

  1467.                         {

  1468.                             event->midi.dataExt = data;

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

  1470.                         }

  1471.                         else

  1472.                         {

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

  1474. 

  1475.                             uint8_t i=1;

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

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

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

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

  1480. 

  1481.                             event->midi.dataExt = nullptr;

  1482.                         }

  1483.                     }

  1484.                     break;

  1485.                 }

  1486. 

  1487.                 case kPluginBridgeRtClientProcess: {

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

  1489. 

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

  1491. 

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

  1493.                     {

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

  1495. 

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

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

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

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

  1500. 

  1501.                         const float* audioIn[64];

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

  1503.                         const float* cvIn[32];

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

  1505. 

  1506.                         float* fdata = fShmAudioPool.data;

  1507. 

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

  1509.                             audioIn[i] = fdata;

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

  1511.                             audioOut[i] = fdata;

  1512. 

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

  1514.                             cvIn[i] = fdata;

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

  1516.                             cvOut[i] = fdata;

  1517. 

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

  1519. 

  1520.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1521.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1522.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1524. 

  1525.                         if (timeInfo.bbt.valid)

  1526.                         {

  1527.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1528.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1529.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1530. 

  1531.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1532.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1533. 

  1534.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1535.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1536.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1537.                         }

  1538. 

  1539.                         plugin->initBuffers();

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

  1541.                         plugin->unlock();

  1542.                     }

  1543. 

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

  1545.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1546.                     std::size_t curMidiDataPos = 0;

  1547. 

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

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

  1550. 

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

  1552.                     {

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

  1554.                         {

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

  1556. 

  1557.                             if (event.type == kEngineEventTypeNull)

  1558.                                 break;

  1559. 

  1560.                             if (event.type == kEngineEventTypeControl)

  1561.                             {

  1562.                                 uint8_t data[3];

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

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

  1565. 

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

  1567.                                     break;

  1568. 

  1569.                                 // set time

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

  1571.                                 midiData = midiData + 4;

  1572.                                 curMidiDataPos += 4;

  1573. 

  1574.                                 // set port

  1575.                                 *midiData++ = 0;

  1576.                                 ++curMidiDataPos;

  1577. 

  1578.                                 // set size

  1579.                                 *midiData++ = size;

  1580.                                 ++curMidiDataPos;

  1581. 

  1582.                                 // set data

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

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

  1585. 

  1586.                                 curMidiDataPos += size;

  1587.                             }

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

  1589.                             {

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

  1591. 

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

  1593.                                     break;

  1594. 

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

  1596. 

  1597.                                 // set time

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

  1599.                                 midiData += 4;

  1600.                                 curMidiDataPos += 4;

  1601. 

  1602.                                 // set port

  1603.                                 *midiData++ = _midiEvent.port;

  1604.                                 ++curMidiDataPos;

  1605. 

  1606.                                 // set size

  1607.                                 *midiData++ = _midiEvent.size;

  1608.                                 ++curMidiDataPos;

  1609. 

  1610.                                 // set data

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

  1612. 

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

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

  1615. 

  1616.                                 curMidiDataPos += _midiEvent.size;

  1617.                             }

  1618.                         }

  1619. 

  1620.                         if (curMidiDataPos != 0 &&

  1621.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1622.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1623. 

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

  1625.                     }

  1626. 

  1627.                 }   break;

  1628. 

  1629.                 case kPluginBridgeRtClientQuit: {

  1630.                     quitReceived = true;

  1631.                     fClosingDown = true;

  1632.                     signalThreadShouldExit();

  1633.                 }   break;

  1634.                 }

  1635.             }

  1636.         }

  1637. 

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

  1639. 

  1640.         if (! quitReceived)

  1641.         {

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

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

  1644. 

  1645.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1646.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1647.             fShmNonRtServerControl.writeUInt(messageSize);

  1648.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1649.             fShmNonRtServerControl.commitWrite();

  1650.         }

  1651.     }

  1652. 

  1653.     // called from process thread above

  1654.     EngineEvent* getNextFreeInputEvent() const noexcept

  1655.     {

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

  1657.         {

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

  1659. 

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

  1661.                 return event;

  1662.         }

  1663.         return nullptr;

  1664.     }

  1665. 

  1666.     void latencyChanged(const uint32_t samples) noexcept override

  1667.     {

  1668.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1669. 

  1670.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1671.         fShmNonRtServerControl.writeUInt(samples);

  1672.         fShmNonRtServerControl.commitWrite();

  1673.     }

  1674. 

  1675.     // -------------------------------------------------------------------

  1676. 

  1677. private:

  1678.     BridgeAudioPool          fShmAudioPool;

  1679.     BridgeRtClientControl    fShmRtClientControl;

  1680.     BridgeNonRtClientControl fShmNonRtClientControl;

  1681.     BridgeNonRtServerControl fShmNonRtServerControl;

  1682. 

  1683.     CarlaString fBaseNameAudioPool;

  1684.     CarlaString fBaseNameRtClientControl;

  1685.     CarlaString fBaseNameNonRtClientControl;

  1686.     CarlaString fBaseNameNonRtServerControl;

  1687. 

  1688.     bool fClosingDown;

  1689.     bool fIsOffline;

  1690.     bool fFirstIdle;

  1691.     uint32_t fBridgeVersion;

  1692.     int64_t fLastPingTime;

  1693. 

  1694.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1695. };

  1696. 

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

  1698. 

  1699. namespace EngineInit {

  1700. 

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

  1702.                        const char* const rtClientBaseName,

  1703.                        const char* const nonRtClientBaseName,

  1704.                        const char* const nonRtServerBaseName)

  1705. {

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

  1707. }

  1708. 

  1709. }

  1710. 

  1711. // -----------------------------------------------------------------------

  1712. 

  1713. CARLA_BACKEND_END_NAMESPACE

  1714. 

  1715. // -----------------------------------------------------------------------

  1716. 

  1717. #include "CarlaBridgeUtils.cpp"

  1718. 

  1719. // -----------------------------------------------------------------------