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

1499 lines
60KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2019 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #ifndef BUILD_BRIDGE

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

  20. #endif

  21. 

  22. #include "CarlaEngineInternal.hpp"

  23. #include "CarlaPlugin.hpp"

  24. 

  25. #include "CarlaBackendUtils.hpp"

  26. #include "CarlaBase64Utils.hpp"

  27. #include "CarlaBridgeUtils.hpp"

  28. #include "CarlaMIDI.h"

  29. 

  30. #ifdef __SSE2_MATH__

  31. # include <xmmintrin.h>

  32. #endif

  33. 

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

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

  36. 

  37. // must be last

  38. #include "jackbridge/JackBridge.hpp"

  39. 

  40. using water::File;

  41. using water::MemoryBlock;

  42. using water::String;

  43. using water::Time;

  44. 

  45. CARLA_BACKEND_START_NAMESPACE

  46. 

  47. // -----------------------------------------------------------------------

  48. // Bridge Engine client

  49. 

  50. struct LatencyChangedCallback {

  51.     virtual ~LatencyChangedCallback() noexcept {}

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

  53. };

  54. 

  55. class CarlaEngineBridgeClient : public CarlaEngineClient

  56. {

  57. public:

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

  59.         : CarlaEngineClient(engine),

  60.           fLatencyCallback(cb) {}

  61. 

  62. protected:

  63.     void setLatency(const uint32_t samples) noexcept override

  64.     {

  65.         if (getLatency() == samples)

  66.             return;

  67. 

  68.         fLatencyCallback->latencyChanged(samples);

  69.         CarlaEngineClient::setLatency(samples);

  70.     }

  71. 

  72. private:

  73.     LatencyChangedCallback* const fLatencyCallback;

  74. 

  75.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  76. };

  77. 

  78. // -------------------------------------------------------------------

  79. 

  80. class CarlaEngineBridge : public CarlaEngine,

  81.                           private CarlaThread,

  82.                           private LatencyChangedCallback

  83. {

  84. public:

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

  86.         : CarlaEngine(),

  87.           CarlaThread("CarlaEngineBridge"),

  88.           fShmAudioPool(),

  89.           fShmRtClientControl(),

  90.           fShmNonRtClientControl(),

  91.           fShmNonRtServerControl(),

  92.           fBaseNameAudioPool(audioPoolBaseName),

  93.           fBaseNameRtClientControl(rtClientBaseName),

  94.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  95.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  96.           fClosingDown(false),

  97.           fIsOffline(false),

  98.           fFirstIdle(true),

  99.           fLastPingTime(-1)

  100.     {

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

  102.     }

  103. 

  104.     ~CarlaEngineBridge() noexcept override

  105.     {

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

  107. 

  108.         clear();

  109.     }

  110. 

  111.     // -------------------------------------

  112.     // CarlaEngine virtual calls

  113. 

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

  115.     {

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

  117. 

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

  119.         {

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

  121.             return false;

  122.         }

  123. 

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

  125.         {

  126.             carla_stderr("Failed to attach to audio pool shared memory");

  127.             return false;

  128.         }

  129. 

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

  131.         {

  132.             clear();

  133.             carla_stderr("Failed to attach to rt client control shared memory");

  134.             return false;

  135.         }

  136. 

  137.         if (! fShmRtClientControl.mapData())

  138.         {

  139.             clear();

  140.             carla_stderr("Failed to map rt client control shared memory");

  141.             return false;

  142.         }

  143. 

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

  145.         {

  146.             clear();

  147.             carla_stderr("Failed to attach to non-rt client control shared memory");

  148.             return false;

  149.         }

  150. 

  151.         if (! fShmNonRtClientControl.mapData())

  152.         {

  153.             clear();

  154.             carla_stderr("Failed to map non-rt control client shared memory");

  155.             return false;

  156.         }

  157. 

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

  159.         {

  160.             clear();

  161.             carla_stderr("Failed to attach to non-rt server control shared memory");

  162.             return false;

  163.         }

  164. 

  165.         if (! fShmNonRtServerControl.mapData())

  166.         {

  167.             clear();

  168.             carla_stderr("Failed to map non-rt control server shared memory");

  169.             return false;

  170.         }

  171. 

  172.         PluginBridgeNonRtClientOpcode opcode;

  173. 

  174.         opcode = fShmNonRtClientControl.readOpcode();

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

  176. 

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

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

  179. 

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

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

  182. 

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

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

  185. 

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

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

  188. 

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

  190.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  191.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  192.         {

  193.             carla_stderr2("CarlaEngineBridge: data size mismatch");

  194.             return false;

  195.         }

  196. 

  197.         opcode = fShmNonRtClientControl.readOpcode();

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

  199. 

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

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

  202. 

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

  204.         {

  205.             carla_stderr2("CarlaEngineBridge: invalid empty state");

  206.             return false;

  207.         }

  208. 

  209.         pData->initTime(nullptr);

  210. 

  211.         // tell backend we're live

  212.         {

  213.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  214. 

  215.             // kPluginBridgeNonRtServerVersion was added in API 7

  216.             if (apiVersion >= 7)

  217.             {

  218.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  219.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  220.             }

  221.             else

  222.             {

  223.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  224.             }

  225. 

  226.             fShmNonRtServerControl.commitWrite();

  227.         }

  228. 

  229.         startThread(true);

  230.         return true;

  231.     }

  232. 

  233.     bool close() override

  234.     {

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

  236.         fLastPingTime = -1;

  237. 

  238.         CarlaEngine::close();

  239. 

  240.         stopThread(5000);

  241.         clear();

  242. 

  243.         return true;

  244.     }

  245. 

  246.     bool isRunning() const noexcept override

  247.     {

  248.         if (fClosingDown)

  249.             return false;

  250. 

  251.         return isThreadRunning() || ! fFirstIdle;

  252.     }

  253. 

  254.     bool isOffline() const noexcept override

  255.     {

  256.         return fIsOffline;

  257.     }

  258. 

  259.     EngineType getType() const noexcept override

  260.     {

  261.         return kEngineTypeBridge;

  262.     }

  263. 

  264.     const char* getCurrentDriverName() const noexcept override

  265.     {

  266.         return "Bridge";

  267.     }

  268. 

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

  270.     {

  271.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  272. 

  273.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  274.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  275.         fShmNonRtServerControl.writeUInt(parameterId);

  276.         fShmNonRtServerControl.writeBool(touch);

  277.         fShmNonRtServerControl.commitWrite();

  278.     }

  279. 

  280.     CarlaEngineClient* addClient(CarlaPlugin* const) override

  281.     {

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

  283.     }

  284. 

  285.     void idle() noexcept override

  286.     {

  287.         CarlaPlugin* const plugin(pData->plugins[0].plugin);

  288. 

  289.         if (plugin == nullptr)

  290.         {

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

  292.             {

  293.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  294.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  295.                 fShmNonRtServerControl.writeUInt(length);

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

  297.                 fShmNonRtServerControl.commitWrite();

  298.             }

  299. 

  300.             signalThreadShouldExit();

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

  302.             return;

  303.         }

  304. 

  305.         const bool wasFirstIdle(fFirstIdle);

  306. 

  307.         if (wasFirstIdle)

  308.         {

  309.             fFirstIdle = false;

  310.             fLastPingTime = Time::currentTimeMillis();

  311.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  312. 

  313.             char bufStr[STR_MAX+1];

  314.             carla_zeroChars(bufStr, STR_MAX+1);

  315. 

  316.             uint32_t bufStrSize;

  317. 

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

  319.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  320. 

  321.             // kPluginBridgeNonRtServerPluginInfo1

  322.             {

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

  324.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  330.                 fShmNonRtServerControl.commitWrite();

  331.             }

  332. 

  333.             // kPluginBridgeNonRtServerPluginInfo2

  334.             {

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

  336.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  337. 

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

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

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

  341.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  342.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  343. 

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

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

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

  347.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  348.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  349. 

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

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

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

  353.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  354.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  355. 

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

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

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

  359.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  360.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  361. 

  362.                 fShmNonRtServerControl.commitWrite();

  363.             }

  364. 

  365.             // kPluginBridgeNonRtServerAudioCount

  366.             {

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

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

  369. 

  370.                 // uint/ins, uint/outs

  371.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  372.                 fShmNonRtServerControl.writeUInt(aIns);

  373.                 fShmNonRtServerControl.writeUInt(aOuts);

  374.                 fShmNonRtServerControl.commitWrite();

  375. 

  376.                 // kPluginBridgeNonRtServerPortName

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

  378.                 {

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

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

  381. 

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

  383.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  384.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  385.                     fShmNonRtServerControl.writeUInt(i);

  386. 

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

  388.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  389.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  390.                 }

  391. 

  392.                 // kPluginBridgeNonRtServerPortName

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

  394.                 {

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

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

  397. 

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

  399.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  400.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  401.                     fShmNonRtServerControl.writeUInt(i);

  402. 

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

  404.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  405.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  406.                 }

  407.             }

  408. 

  409.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  410. 

  411.             // kPluginBridgeNonRtServerMidiCount

  412.             {

  413.                 // uint/ins, uint/outs

  414.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  417.                 fShmNonRtServerControl.commitWrite();

  418.             }

  419. 

  420.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  421. 

  422.             // kPluginBridgeNonRtServerCvCount

  423.             {

  424.                 // uint/ins, uint/outs

  425.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  428.                 fShmNonRtServerControl.commitWrite();

  429.             }

  430. 

  431.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  432. 

  433.             // kPluginBridgeNonRtServerParameter*

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

  435.             {

  436.                 // uint/count

  437.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  438.                 fShmNonRtServerControl.writeUInt(count);

  439.                 fShmNonRtServerControl.commitWrite();

  440. 

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

  442.                 {

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

  444. 

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

  446.                         continue;

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

  448.                         continue;

  449. 

  450.                     // kPluginBridgeNonRtServerParameterData1

  451.                     {

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

  453.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  454.                         fShmNonRtServerControl.writeUInt(i);

  455.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  456.                         fShmNonRtServerControl.writeUInt(paramData.type);

  457.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  458.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  459.                         fShmNonRtServerControl.commitWrite();

  460.                     }

  461. 

  462.                     // kPluginBridgeNonRtServerParameterData2

  463.                     {

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

  465.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  466.                         fShmNonRtServerControl.writeUInt(i);

  467. 

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

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

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

  471.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  472.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  473. 

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

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

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

  477.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  478.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  479. 

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

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

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

  483.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  484.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  485. 

  486.                         fShmNonRtServerControl.commitWrite();

  487.                     }

  488. 

  489.                     // kPluginBridgeNonRtServerParameterRanges

  490.                     {

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

  492. 

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

  494.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  495.                         fShmNonRtServerControl.writeUInt(i);

  496.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  497.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  498.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  499.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  500.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  501.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  502.                         fShmNonRtServerControl.commitWrite();

  503.                     }

  504. 

  505.                     // kPluginBridgeNonRtServerParameterValue2

  506.                     {

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

  508.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  509.                         fShmNonRtServerControl.writeUInt(i);

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

  511.                         fShmNonRtServerControl.commitWrite();

  512.                     }

  513. 

  514.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  515.                 }

  516.             }

  517. 

  518.             // kPluginBridgeNonRtServerProgram*

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

  520.             {

  521.                 // uint/count

  522.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  523.                 fShmNonRtServerControl.writeUInt(count);

  524.                 fShmNonRtServerControl.commitWrite();

  525. 

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

  527.                 {

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

  529.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  530.                     fShmNonRtServerControl.writeUInt(i);

  531. 

  532.                     if (plugin->getProgramName(i, bufStr))

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

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

  535.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  536.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  537. 

  538.                     fShmNonRtServerControl.commitWrite();

  539.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  540.                 }

  541.             }

  542. 

  543.             // kPluginBridgeNonRtServerMidiProgram*

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

  545.             {

  546.                 // uint/count

  547.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  548.                 fShmNonRtServerControl.writeUInt(count);

  549.                 fShmNonRtServerControl.commitWrite();

  550. 

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

  552.                 {

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

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

  555. 

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

  557.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  558.                     fShmNonRtServerControl.writeUInt(i);

  559.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  560.                     fShmNonRtServerControl.writeUInt(mpData.program);

  561. 

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

  563.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  565. 

  566.                     fShmNonRtServerControl.commitWrite();

  567.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  568.                 }

  569.             }

  570. 

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

  572.             {

  573.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  574.                 fShmNonRtServerControl.writeUInt(latency);

  575.                 fShmNonRtServerControl.commitWrite();

  576.             }

  577. 

  578.             // ready!

  579.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  580.             fShmNonRtServerControl.commitWrite();

  581.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  582. 

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

  584.             fLastPingTime = Time::currentTimeMillis();

  585.         }

  586. 

  587.         // send parameter outputs

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

  589.         {

  590.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  591. 

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

  593.             {

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

  595.                     continue;

  596. 

  597.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  598.                 fShmNonRtServerControl.writeUInt(i);

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

  600. 

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

  602.                 if (! fShmNonRtServerControl.commitWrite())

  603.                     break;

  604.             }

  605.         }

  606. 

  607.         CarlaEngine::idle();

  608. 

  609.         try {

  610.             handleNonRtData();

  611.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  612. 

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

  614.         {

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

  616.             signalThreadShouldExit();

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

  618.         }

  619.     }

  620. 

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

  622.                   const EngineCallbackOpcode action, const uint pluginId,

  623.                   const int value1, const int value2, const int value3,

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

  625.     {

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

  627. 

  628.         if (fClosingDown)

  629.             return;

  630. 

  631.         switch (action)

  632.         {

  633.         // uint/index float/value

  634.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  635.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  636.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  637.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  639.             fShmNonRtServerControl.writeFloat(valuef);

  640.             fShmNonRtServerControl.commitWrite();

  641.         }   break;

  642. 

  643.         // uint/index float/value

  644.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  645.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  646.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  647.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  649.             fShmNonRtServerControl.writeFloat(valuef);

  650.             fShmNonRtServerControl.commitWrite();

  651.         }   break;

  652. 

  653.         // int/index

  654.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  655.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  656.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  657.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  658.             fShmNonRtServerControl.writeInt(value1);

  659.             fShmNonRtServerControl.commitWrite();

  660.         }   break;

  661. 

  662.         // int/index

  663.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  664.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  665.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  666.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  667.             fShmNonRtServerControl.writeInt(value1);

  668.             fShmNonRtServerControl.commitWrite();

  669.         }   break;

  670. 

  671.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  672.             if (value1 != 1)

  673.             {

  674.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  675.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  676.                 fShmNonRtServerControl.commitWrite();

  677.             }

  678.             break;

  679. 

  680.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  681.             if (CarlaPlugin* const plugin = pData->plugins[0].plugin)

  682.             {

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

  684.                 {

  685.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  686. 

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

  688.                     {

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

  690. 

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

  692.                             continue;

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

  694.                             continue;

  695. 

  696.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  697.                         fShmNonRtServerControl.writeUInt(i);

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

  699.                         fShmNonRtServerControl.commitWrite();

  700. 

  701.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  702.                     }

  703.                 }

  704.             }

  705.             break;

  706. 

  707.         default:

  708.             break;

  709.         }

  710.     }

  711. 

  712.     // -------------------------------------------------------------------

  713. 

  714.     void clear() noexcept

  715.     {

  716.         fShmAudioPool.clear();

  717.         fShmRtClientControl.clear();

  718.         fShmNonRtClientControl.clear();

  719.         fShmNonRtServerControl.clear();

  720.     }

  721. 

  722.     void handleNonRtData()

  723.     {

  724.         CarlaPlugin* const plugin(pData->plugins[0].plugin);

  725.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  726. 

  727.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  728.         {

  729.             const PluginBridgeNonRtClientOpcode opcode(fShmNonRtClientControl.readOpcode());

  730. 

  731. #ifdef DEBUG

  732.             if (opcode != kPluginBridgeNonRtClientPing) {

  733.                 carla_debug("CarlaEngineBridge::handleNonRtData() - got opcode: %s", PluginBridgeNonRtClientOpcode2str(opcode));

  734.             }

  735. #endif

  736. 

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

  738.                 fLastPingTime = Time::currentTimeMillis();

  739. 

  740.             switch (opcode)

  741.             {

  742.             case kPluginBridgeNonRtClientNull:

  743.                 break;

  744. 

  745.             case kPluginBridgeNonRtClientVersion: {

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

  747.                 CARLA_SAFE_ASSERT_UINT2(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  748.                                         apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  749.             }   break;

  750. 

  751.             case kPluginBridgeNonRtClientPing: {

  752.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  753. 

  754.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  755.                 fShmNonRtServerControl.commitWrite();

  756.             }   break;

  757. 

  758.             case kPluginBridgeNonRtClientPingOnOff: {

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

  760. 

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

  762.             }   break;

  763. 

  764.             case kPluginBridgeNonRtClientActivate:

  765.                 if (plugin != nullptr && plugin->isEnabled())

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

  767.                 break;

  768. 

  769.             case kPluginBridgeNonRtClientDeactivate:

  770.                 if (plugin != nullptr && plugin->isEnabled())

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

  772.                 break;

  773. 

  774.             case kPluginBridgeNonRtClientInitialSetup:

  775.                 // should never happen!!

  776.                 fShmNonRtServerControl.readUInt();

  777.                 fShmNonRtServerControl.readDouble();

  778.                 break;

  779. 

  780.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  783. 

  784.                 if (plugin != nullptr && plugin->isEnabled())

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

  786.                 break;

  787.             }

  788. 

  789.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  792. 

  793.                 if (plugin != nullptr && plugin->isEnabled())

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

  795.                 break;

  796.             }

  797. 

  798.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

  800.                 const int16_t  cc(fShmNonRtClientControl.readShort());

  801. 

  802.                 if (plugin != nullptr && plugin->isEnabled())

  803.                     plugin->setParameterMidiCC(index, cc, false, false);

  804.                 break;

  805.             }

  806. 

  807.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  811. 

  812.                 if (plugin != nullptr && plugin->isEnabled())

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

  814.                 break;

  815.             }

  816. 

  817.             case kPluginBridgeNonRtClientSetProgram: {

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

  819. 

  820.                 if (plugin != nullptr && plugin->isEnabled())

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

  822.                 break;

  823.             }

  824. 

  825.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  827. 

  828.                 if (plugin != nullptr && plugin->isEnabled())

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

  830.                 break;

  831.             }

  832. 

  833.             case kPluginBridgeNonRtClientSetCustomData: {

  834.                 // type

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

  836.                 char typeStr[typeSize+1];

  837.                 carla_zeroChars(typeStr, typeSize+1);

  838.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  839. 

  840.                 // key

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

  842.                 char keyStr[keySize+1];

  843.                 carla_zeroChars(keyStr, keySize+1);

  844.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  845. 

  846.                 // value

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

  848.                 char valueStr[valueSize+1];

  849.                 carla_zeroChars(valueStr, valueSize+1);

  850. 

  851.                 if (valueSize > 0)

  852.                     fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  853. 

  854.                 if (plugin != nullptr && plugin->isEnabled())

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

  856.                 break;

  857.             }

  858. 

  859.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  861.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  862. 

  863.                 char chunkFilePathTry[size+1];

  864.                 carla_zeroChars(chunkFilePathTry, size+1);

  865.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  866. 

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

  868.                 if (plugin == nullptr || ! plugin->isEnabled()) break;

  869. 

  870.                 String chunkFilePath(chunkFilePathTry);

  871. 

  872. #ifdef CARLA_OS_WIN

  873.                 // check if running under Wine

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

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

  876. #endif

  877. 

  878.                 File chunkFile(chunkFilePath);

  879.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  880. 

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

  882.                 chunkFile.deleteFile();

  883.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  884. 

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

  886. 

  887. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  889. #else

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

  891. #endif

  892.                 break;

  893.             }

  894. 

  895.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  898. 

  899.                 if (plugin != nullptr && plugin->isEnabled())

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

  901.                 break;

  902.             }

  903. 

  904.             case kPluginBridgeNonRtClientSetOption: {

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

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

  907. 

  908.                 if (plugin != nullptr && plugin->isEnabled())

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

  910.                 break;

  911.             }

  912. 

  913.             case kPluginBridgeNonRtClientGetParameterText: {

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

  915. 

  916.                 if (index >= 0 && plugin != nullptr && plugin->isEnabled())

  917.                 {

  918.                     char bufStr[STR_MAX+1];

  919.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  922. 

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

  924. 

  925.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  926. 

  927.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  928. 

  929.                     fShmNonRtServerControl.writeInt(index);

  930.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  931.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  932.                     fShmNonRtServerControl.commitWrite();

  933. 

  934.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  935.                 }

  936. 

  937.                 break;

  938.             }

  939. 

  940.             case kPluginBridgeNonRtClientPrepareForSave: {

  941.                 if (plugin == nullptr || ! plugin->isEnabled())

  942.                     break;

  943. 

  944.                 plugin->prepareForSave();

  945. 

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

  947.                 {

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

  949. 

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

  951.                         continue;

  952. 

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

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

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

  956. 

  957.                     {

  958.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  959. 

  960.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  961. 

  962.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  964. 

  965.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  967. 

  968.                         fShmNonRtServerControl.writeUInt(valueLen);

  969. 

  970.                         if (valueLen > 0)

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

  972. 

  973.                         fShmNonRtServerControl.commitWrite();

  974.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  975.                     }

  976.                 }

  977. 

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

  979.                 {

  980.                     void* data = nullptr;

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

  982.                     {

  983.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  984. 

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

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

  987. 

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

  989. 

  990.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  991.                         filePath += fShmAudioPool.getFilenameSuffix();

  992. 

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

  994.                         {

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

  996. 

  997.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  998. 

  999.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1000.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1002.                             fShmNonRtServerControl.commitWrite();

  1003.                         }

  1004.                     }

  1005.                 }

  1006. 

  1007.                 {

  1008.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1009. 

  1010.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1011.                     fShmNonRtServerControl.commitWrite();

  1012.                 }

  1013.                 break;

  1014.             }

  1015. 

  1016.             case kPluginBridgeNonRtClientRestoreLV2State:

  1017.                 if (plugin != nullptr && plugin->isEnabled())

  1018.                     plugin->restoreLV2State();

  1019.                 break;

  1020. 

  1021.             case kPluginBridgeNonRtClientShowUI:

  1022.                 if (plugin != nullptr && plugin->isEnabled())

  1023.                     plugin->showCustomUI(true);

  1024.                 break;

  1025. 

  1026.             case kPluginBridgeNonRtClientHideUI:

  1027.                 if (plugin != nullptr && plugin->isEnabled())

  1028.                     plugin->showCustomUI(false);

  1029.                 break;

  1030. 

  1031.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1034. 

  1035.                 if (plugin != nullptr && plugin->isEnabled())

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

  1037.                 break;

  1038.             }

  1039. 

  1040.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1042. 

  1043.                 if (plugin != nullptr && plugin->isEnabled())

  1044.                     plugin->uiProgramChange(index);

  1045.                 break;

  1046.             }

  1047. 

  1048.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1050. 

  1051.                 if (plugin != nullptr && plugin->isEnabled())

  1052.                     plugin->uiMidiProgramChange(index);

  1053.                 break;

  1054.             }

  1055. 

  1056.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1060. 

  1061.                 if (plugin != nullptr && plugin->isEnabled())

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

  1063.                 break;

  1064.             }

  1065. 

  1066.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1069. 

  1070.                 if (plugin != nullptr && plugin->isEnabled())

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

  1072.                 break;

  1073.             }

  1074. 

  1075.             case kPluginBridgeNonRtClientQuit:

  1076.                 fClosingDown = true;

  1077.                 signalThreadShouldExit();

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

  1079.                 break;

  1080.             }

  1081.         }

  1082.     }

  1083. 

  1084.     // -------------------------------------------------------------------

  1085. 

  1086. protected:

  1087.     void run() override

  1088.     {

  1089. #ifdef __SSE2_MATH__

  1090.         // Set FTZ and DAZ flags

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

  1092. #endif

  1093. 

  1094.         bool quitReceived = false;

  1095. 

  1096.         for (; ! shouldThreadExit();)

  1097.         {

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

  1099. 

  1100.             if (! helper.ok)

  1101.                 continue;

  1102. 

  1103.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1104.             {

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

  1106.                 CarlaPlugin* const plugin(pData->plugins[0].plugin);

  1107. 

  1108. #ifdef DEBUG

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

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

  1111.                 }

  1112. #endif

  1113. 

  1114.                 switch (opcode)

  1115.                 {

  1116.                 case kPluginBridgeRtClientNull:

  1117.                     break;

  1118. 

  1119.                 case kPluginBridgeRtClientSetAudioPool: {

  1120.                     if (fShmAudioPool.data != nullptr)

  1121.                     {

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

  1123.                         fShmAudioPool.data = nullptr;

  1124.                     }

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

  1126.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1128.                     break;

  1129.                 }

  1130. 

  1131.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1133.                     pData->bufferSize = bufferSize;

  1134.                     bufferSizeChanged(bufferSize);

  1135.                     break;

  1136.                 }

  1137. 

  1138.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1140.                     pData->sampleRate = sampleRate;

  1141.                     sampleRateChanged(sampleRate);

  1142.                     break;

  1143.                 }

  1144. 

  1145.                 case kPluginBridgeRtClientSetOnline:

  1146.                     fIsOffline = fShmRtClientControl.readBool();

  1147.                     offlineModeChanged(fIsOffline);

  1148.                     break;

  1149. 

  1150.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1155. 

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

  1157.                     {

  1158.                         event->type    = kEngineEventTypeControl;

  1159.                         event->time    = time;

  1160.                         event->channel = channel;

  1161.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1162.                         event->ctrl.param = param;

  1163.                         event->ctrl.value = value;

  1164.                     }

  1165.                     break;

  1166.                 }

  1167. 

  1168.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1172. 

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

  1174.                     {

  1175.                         event->type    = kEngineEventTypeControl;

  1176.                         event->time    = time;

  1177.                         event->channel = channel;

  1178.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1179.                         event->ctrl.param = index;

  1180.                         event->ctrl.value = 0.0f;

  1181.                     }

  1182.                     break;

  1183.                 }

  1184. 

  1185.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1189. 

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

  1191.                     {

  1192.                         event->type    = kEngineEventTypeControl;

  1193.                         event->time    = time;

  1194.                         event->channel = channel;

  1195.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1196.                         event->ctrl.param = index;

  1197.                         event->ctrl.value = 0.0f;

  1198.                     }

  1199.                     break;

  1200.                 }

  1201. 

  1202.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1205. 

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

  1207.                     {

  1208.                         event->type    = kEngineEventTypeControl;

  1209.                         event->time    = time;

  1210.                         event->channel = channel;

  1211.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1212.                         event->ctrl.param = 0;

  1213.                         event->ctrl.value = 0.0f;

  1214.                     }

  1215.                 }   break;

  1216. 

  1217.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1220. 

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

  1222.                     {

  1223.                         event->type    = kEngineEventTypeControl;

  1224.                         event->time    = time;

  1225.                         event->channel = channel;

  1226.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1227.                         event->ctrl.param = 0;

  1228.                         event->ctrl.value = 0.0f;

  1229.                     }

  1230.                 }   break;

  1231. 

  1232.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1236.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1237. 

  1238.                     // FIXME variable-size stack

  1239.                     uint8_t data[size];

  1240. 

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

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

  1243. 

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

  1245.                     {

  1246.                         event->type    = kEngineEventTypeMidi;

  1247.                         event->time    = time;

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

  1249. 

  1250.                         event->midi.port = port;

  1251.                         event->midi.size = size;

  1252. 

  1253.                         if (size > EngineMidiEvent::kDataSize)

  1254.                         {

  1255.                             event->midi.dataExt = data;

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

  1257.                         }

  1258.                         else

  1259.                         {

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

  1261. 

  1262.                             uint8_t i=1;

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

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

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

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

  1267. 

  1268.                             event->midi.dataExt = nullptr;

  1269.                         }

  1270.                     }

  1271.                     break;

  1272.                 }

  1273. 

  1274.                 case kPluginBridgeRtClientProcess: {

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

  1276. 

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

  1278. 

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

  1280.                     {

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

  1282. 

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

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

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

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

  1287. 

  1288.                         const float* audioIn[audioInCount];

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

  1290.                         const float* cvIn[cvInCount];

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

  1292. 

  1293.                         float* fdata = fShmAudioPool.data;

  1294. 

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

  1296.                             audioIn[i] = fdata;

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

  1298.                             audioOut[i] = fdata;

  1299. 

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

  1301.                             cvIn[i] = fdata;

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

  1303.                             cvOut[i] = fdata;

  1304. 

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

  1306. 

  1307.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1308.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1309.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1311. 

  1312.                         if (timeInfo.bbt.valid)

  1313.                         {

  1314.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1315.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1316.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1317. 

  1318.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1319.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1320. 

  1321.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1322.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1323.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1324.                         }

  1325. 

  1326.                         plugin->initBuffers();

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

  1328.                         plugin->unlock();

  1329.                     }

  1330. 

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

  1332.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1333.                     std::size_t curMidiDataPos = 0;

  1334. 

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

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

  1337. 

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

  1339.                     {

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

  1341.                         {

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

  1343. 

  1344.                             if (event.type == kEngineEventTypeNull)

  1345.                                 break;

  1346. 

  1347.                             if (event.type == kEngineEventTypeControl)

  1348.                             {

  1349.                                 uint8_t data[3];

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

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

  1352. 

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

  1354.                                     break;

  1355. 

  1356.                                 // set time

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

  1358.                                 midiData = midiData + 4;

  1359.                                 curMidiDataPos += 4;

  1360. 

  1361.                                 // set port

  1362.                                 *midiData++ = 0;

  1363.                                 ++curMidiDataPos;

  1364. 

  1365.                                 // set size

  1366.                                 *midiData++ = size;

  1367.                                 ++curMidiDataPos;

  1368. 

  1369.                                 // set data

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

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

  1372. 

  1373.                                 curMidiDataPos += size;

  1374.                             }

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

  1376.                             {

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

  1378. 

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

  1380.                                     break;

  1381. 

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

  1383. 

  1384.                                 // set time

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

  1386.                                 midiData += 4;

  1387.                                 curMidiDataPos += 4;

  1388. 

  1389.                                 // set port

  1390.                                 *midiData++ = _midiEvent.port;

  1391.                                 ++curMidiDataPos;

  1392. 

  1393.                                 // set size

  1394.                                 *midiData++ = _midiEvent.size;

  1395.                                 ++curMidiDataPos;

  1396. 

  1397.                                 // set data

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

  1399. 

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

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

  1402. 

  1403.                                 curMidiDataPos += _midiEvent.size;

  1404.                             }

  1405.                         }

  1406. 

  1407.                         if (curMidiDataPos != 0 &&

  1408.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1409.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1410. 

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

  1412.                     }

  1413. 

  1414.                 }   break;

  1415. 

  1416.                 case kPluginBridgeRtClientQuit: {

  1417.                     quitReceived = true;

  1418.                     fClosingDown = true;

  1419.                     signalThreadShouldExit();

  1420.                 }   break;

  1421.                 }

  1422.             }

  1423.         }

  1424. 

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

  1426. 

  1427.         if (! quitReceived)

  1428.         {

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

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

  1431. 

  1432.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1433.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1434.             fShmNonRtServerControl.writeUInt(messageSize);

  1435.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1436.             fShmNonRtServerControl.commitWrite();

  1437.         }

  1438.     }

  1439. 

  1440.     // called from process thread above

  1441.     EngineEvent* getNextFreeInputEvent() const noexcept

  1442.     {

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

  1444.         {

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

  1446. 

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

  1448.                 return event;

  1449.         }

  1450.         return nullptr;

  1451.     }

  1452. 

  1453.     void latencyChanged(const uint32_t samples) noexcept override

  1454.     {

  1455.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1456. 

  1457.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1458.         fShmNonRtServerControl.writeUInt(samples);

  1459.         fShmNonRtServerControl.commitWrite();

  1460.     }

  1461. 

  1462.     // -------------------------------------------------------------------

  1463. 

  1464. private:

  1465.     BridgeAudioPool          fShmAudioPool;

  1466.     BridgeRtClientControl    fShmRtClientControl;

  1467.     BridgeNonRtClientControl fShmNonRtClientControl;

  1468.     BridgeNonRtServerControl fShmNonRtServerControl;

  1469. 

  1470.     CarlaString fBaseNameAudioPool;

  1471.     CarlaString fBaseNameRtClientControl;

  1472.     CarlaString fBaseNameNonRtClientControl;

  1473.     CarlaString fBaseNameNonRtServerControl;

  1474. 

  1475.     bool fClosingDown;

  1476.     bool fIsOffline;

  1477.     bool fFirstIdle;

  1478.     int64_t fLastPingTime;

  1479. 

  1480.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1481. };

  1482. 

  1483. // -----------------------------------------------------------------------

  1484. 

  1485. CarlaEngine* CarlaEngine::newBridge(const char* const audioPoolBaseName, const char* const rtClientBaseName, const char* const nonRtClientBaseName, const char* const nonRtServerBaseName)

  1486. {

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

  1488. }

  1489. 

  1490. // -----------------------------------------------------------------------

  1491. 

  1492. CARLA_BACKEND_END_NAMESPACE

  1493. 

  1494. // -----------------------------------------------------------------------

  1495. 

  1496. #include "CarlaBridgeUtils.cpp"

  1497. 

  1498. // -----------------------------------------------------------------------