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

1517 lines
61KB
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. 

  49. // just want to access private options...

  50. struct CarlaPlugin::ProtectedData {

  51.     CarlaEngine* const engine;

  52.     CarlaEngineClient* client;

  53.     uint id, hints, options;

  54.     // ...etc

  55. };

  56. 

  57. // -----------------------------------------------------------------------

  58. // Bridge Engine client

  59. 

  60. struct LatencyChangedCallback {

  61.     virtual ~LatencyChangedCallback() noexcept {}

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

  63. };

  64. 

  65. class CarlaEngineBridgeClient : public CarlaEngineClient

  66. {

  67. public:

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

  69.         : CarlaEngineClient(engine),

  70.           fLatencyCallback(cb) {}

  71. 

  72. protected:

  73.     void setLatency(const uint32_t samples) noexcept override

  74.     {

  75.         if (getLatency() == samples)

  76.             return;

  77. 

  78.         fLatencyCallback->latencyChanged(samples);

  79.         CarlaEngineClient::setLatency(samples);

  80.     }

  81. 

  82. private:

  83.     LatencyChangedCallback* const fLatencyCallback;

  84. 

  85.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  86. };

  87. 

  88. // -------------------------------------------------------------------

  89. 

  90. class CarlaEngineBridge : public CarlaEngine,

  91.                           private CarlaThread,

  92.                           private LatencyChangedCallback

  93. {

  94. public:

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

  96.         : CarlaEngine(),

  97.           CarlaThread("CarlaEngineBridge"),

  98.           fShmAudioPool(),

  99.           fShmRtClientControl(),

  100.           fShmNonRtClientControl(),

  101.           fShmNonRtServerControl(),

  102.           fBaseNameAudioPool(audioPoolBaseName),

  103.           fBaseNameRtClientControl(rtClientBaseName),

  104.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  105.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  106.           fClosingDown(false),

  107.           fIsOffline(false),

  108.           fFirstIdle(true),

  109.           fLastPingTime(-1)

  110.     {

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

  112.     }

  113. 

  114.     ~CarlaEngineBridge() noexcept override

  115.     {

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

  117. 

  118.         clear();

  119.     }

  120. 

  121.     // -------------------------------------

  122.     // CarlaEngine virtual calls

  123. 

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

  125.     {

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

  127. 

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

  129.         {

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

  131.             return false;

  132.         }

  133. 

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

  135.         {

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

  137.             return false;

  138.         }

  139. 

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

  141.         {

  142.             clear();

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

  144.             return false;

  145.         }

  146. 

  147.         if (! fShmRtClientControl.mapData())

  148.         {

  149.             clear();

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

  151.             return false;

  152.         }

  153. 

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

  155.         {

  156.             clear();

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

  158.             return false;

  159.         }

  160. 

  161.         if (! fShmNonRtClientControl.mapData())

  162.         {

  163.             clear();

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

  165.             return false;

  166.         }

  167. 

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

  169.         {

  170.             clear();

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

  172.             return false;

  173.         }

  174. 

  175.         if (! fShmNonRtServerControl.mapData())

  176.         {

  177.             clear();

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

  179.             return false;

  180.         }

  181. 

  182.         PluginBridgeNonRtClientOpcode opcode;

  183. 

  184.         opcode = fShmNonRtClientControl.readOpcode();

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

  186. 

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

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

  189. 

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

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

  192. 

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

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

  195. 

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

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

  198. 

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

  200.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  201.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  202.         {

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

  204.             return false;

  205.         }

  206. 

  207.         opcode = fShmNonRtClientControl.readOpcode();

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

  209. 

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

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

  212. 

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

  214.         {

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

  216.             return false;

  217.         }

  218. 

  219.         pData->initTime(nullptr);

  220. 

  221.         // tell backend we're live

  222.         {

  223.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  224. 

  225.             // kPluginBridgeNonRtServerVersion was added in API 7

  226.             if (apiVersion >= 7)

  227.             {

  228.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  229.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  230.             }

  231.             else

  232.             {

  233.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  234.             }

  235. 

  236.             fShmNonRtServerControl.commitWrite();

  237.         }

  238. 

  239.         startThread(true);

  240.         return true;

  241.     }

  242. 

  243.     bool close() override

  244.     {

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

  246.         fLastPingTime = -1;

  247. 

  248.         CarlaEngine::close();

  249. 

  250.         stopThread(5000);

  251.         clear();

  252. 

  253.         return true;

  254.     }

  255. 

  256.     bool isRunning() const noexcept override

  257.     {

  258.         if (fClosingDown)

  259.             return false;

  260. 

  261.         return isThreadRunning() || ! fFirstIdle;

  262.     }

  263. 

  264.     bool isOffline() const noexcept override

  265.     {

  266.         return fIsOffline;

  267.     }

  268. 

  269.     EngineType getType() const noexcept override

  270.     {

  271.         return kEngineTypeBridge;

  272.     }

  273. 

  274.     const char* getCurrentDriverName() const noexcept override

  275.     {

  276.         return "Bridge";

  277.     }

  278. 

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

  280.     {

  281.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  282. 

  283.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  284.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  285.         fShmNonRtServerControl.writeUInt(parameterId);

  286.         fShmNonRtServerControl.writeBool(touch);

  287.         fShmNonRtServerControl.commitWrite();

  288.     }

  289. 

  290.     CarlaEngineClient* addClient(CarlaPlugin* const) override

  291.     {

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

  293.     }

  294. 

  295.     void idle() noexcept override

  296.     {

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

  298. 

  299.         if (plugin == nullptr)

  300.         {

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

  302.             {

  303.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  304.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  305.                 fShmNonRtServerControl.writeUInt(length);

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

  307.                 fShmNonRtServerControl.commitWrite();

  308.             }

  309. 

  310.             signalThreadShouldExit();

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

  312.             return;

  313.         }

  314. 

  315.         const bool wasFirstIdle(fFirstIdle);

  316. 

  317.         if (wasFirstIdle)

  318.         {

  319.             fFirstIdle = false;

  320.             fLastPingTime = Time::currentTimeMillis();

  321.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  322. 

  323.             char bufStr[STR_MAX+1];

  324.             carla_zeroChars(bufStr, STR_MAX+1);

  325. 

  326.             uint32_t bufStrSize;

  327. 

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

  329.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  330. 

  331.             // kPluginBridgeNonRtServerPluginInfo1

  332.             {

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

  334.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  340.                 fShmNonRtServerControl.commitWrite();

  341.             }

  342. 

  343.             // kPluginBridgeNonRtServerPluginInfo2

  344.             {

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

  346.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  347. 

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

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

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

  351.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  352.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  353. 

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

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

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

  357.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  358.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  359. 

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

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

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

  363.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  364.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  365. 

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

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

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

  369.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  370.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  371. 

  372.                 fShmNonRtServerControl.commitWrite();

  373.             }

  374. 

  375.             // kPluginBridgeNonRtServerAudioCount

  376.             {

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

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

  379. 

  380.                 // uint/ins, uint/outs

  381.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  382.                 fShmNonRtServerControl.writeUInt(aIns);

  383.                 fShmNonRtServerControl.writeUInt(aOuts);

  384.                 fShmNonRtServerControl.commitWrite();

  385. 

  386.                 // kPluginBridgeNonRtServerPortName

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

  388.                 {

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

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

  391. 

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

  393.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  394.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  395.                     fShmNonRtServerControl.writeUInt(i);

  396. 

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

  398.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  399.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  400.                 }

  401. 

  402.                 // kPluginBridgeNonRtServerPortName

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

  404.                 {

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

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

  407. 

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

  409.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  410.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  411.                     fShmNonRtServerControl.writeUInt(i);

  412. 

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

  414.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  415.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  416.                 }

  417.             }

  418. 

  419.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  420. 

  421.             // kPluginBridgeNonRtServerMidiCount

  422.             {

  423.                 // uint/ins, uint/outs

  424.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  427.                 fShmNonRtServerControl.commitWrite();

  428.             }

  429. 

  430.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  431. 

  432.             // kPluginBridgeNonRtServerCvCount

  433.             {

  434.                 // uint/ins, uint/outs

  435.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  438.                 fShmNonRtServerControl.commitWrite();

  439.             }

  440. 

  441.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  442. 

  443.             // kPluginBridgeNonRtServerParameter*

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

  445.             {

  446.                 // uint/count

  447.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  448.                 fShmNonRtServerControl.writeUInt(count);

  449.                 fShmNonRtServerControl.commitWrite();

  450. 

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

  452.                 {

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

  454. 

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

  456.                         continue;

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

  458.                         continue;

  459. 

  460.                     // kPluginBridgeNonRtServerParameterData1

  461.                     {

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

  463.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  464.                         fShmNonRtServerControl.writeUInt(i);

  465.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  466.                         fShmNonRtServerControl.writeUInt(paramData.type);

  467.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  468.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  469.                         fShmNonRtServerControl.commitWrite();

  470.                     }

  471. 

  472.                     // kPluginBridgeNonRtServerParameterData2

  473.                     {

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

  475.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  476.                         fShmNonRtServerControl.writeUInt(i);

  477. 

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

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

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

  481.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  482.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  483. 

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

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

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

  487.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  488.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  489. 

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

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

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

  493.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  494.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  495. 

  496.                         fShmNonRtServerControl.commitWrite();

  497.                     }

  498. 

  499.                     // kPluginBridgeNonRtServerParameterRanges

  500.                     {

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

  502. 

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

  504.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  505.                         fShmNonRtServerControl.writeUInt(i);

  506.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  507.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  508.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  509.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  510.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  511.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  512.                         fShmNonRtServerControl.commitWrite();

  513.                     }

  514. 

  515.                     // kPluginBridgeNonRtServerParameterValue2

  516.                     {

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

  518.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  519.                         fShmNonRtServerControl.writeUInt(i);

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

  521.                         fShmNonRtServerControl.commitWrite();

  522.                     }

  523. 

  524.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  525.                 }

  526.             }

  527. 

  528.             // kPluginBridgeNonRtServerProgram*

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

  530.             {

  531.                 // uint/count

  532.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  533.                 fShmNonRtServerControl.writeUInt(count);

  534.                 fShmNonRtServerControl.commitWrite();

  535. 

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

  537.                 {

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

  539.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  540.                     fShmNonRtServerControl.writeUInt(i);

  541. 

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

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

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

  545.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  546.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  547. 

  548.                     fShmNonRtServerControl.commitWrite();

  549.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  550.                 }

  551.             }

  552. 

  553.             // kPluginBridgeNonRtServerMidiProgram*

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

  555.             {

  556.                 // uint/count

  557.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  558.                 fShmNonRtServerControl.writeUInt(count);

  559.                 fShmNonRtServerControl.commitWrite();

  560. 

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

  562.                 {

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

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

  565. 

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

  567.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  568.                     fShmNonRtServerControl.writeUInt(i);

  569.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  570.                     fShmNonRtServerControl.writeUInt(mpData.program);

  571. 

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

  573.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  575. 

  576.                     fShmNonRtServerControl.commitWrite();

  577.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  578.                 }

  579.             }

  580. 

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

  582.             {

  583.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  584.                 fShmNonRtServerControl.writeUInt(latency);

  585.                 fShmNonRtServerControl.commitWrite();

  586.             }

  587. 

  588.             // ready!

  589.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  590.             fShmNonRtServerControl.commitWrite();

  591.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  592. 

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

  594.             fLastPingTime = Time::currentTimeMillis();

  595.         }

  596. 

  597.         // send parameter outputs

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

  599.         {

  600.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  601. 

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

  603.             {

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

  605.                     continue;

  606. 

  607.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  608.                 fShmNonRtServerControl.writeUInt(i);

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

  610. 

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

  612.                 if (! fShmNonRtServerControl.commitWrite())

  613.                     break;

  614.             }

  615.         }

  616. 

  617.         CarlaEngine::idle();

  618. 

  619.         try {

  620.             handleNonRtData();

  621.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  622. 

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

  624.         {

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

  626.             signalThreadShouldExit();

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

  628.         }

  629.     }

  630. 

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

  632.                   const EngineCallbackOpcode action, const uint pluginId,

  633.                   const int value1, const int value2, const int value3,

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

  635.     {

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

  637. 

  638.         if (fClosingDown)

  639.             return;

  640. 

  641.         switch (action)

  642.         {

  643.         // uint/index float/value

  644.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  645.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  646.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  647.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  649.             fShmNonRtServerControl.writeFloat(valuef);

  650.             fShmNonRtServerControl.commitWrite();

  651.         }   break;

  652. 

  653.         // uint/index float/value

  654.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  655.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  656.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  657.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  659.             fShmNonRtServerControl.writeFloat(valuef);

  660.             fShmNonRtServerControl.commitWrite();

  661.         }   break;

  662. 

  663.         // int/index

  664.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  665.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  666.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  667.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  668.             fShmNonRtServerControl.writeInt(value1);

  669.             fShmNonRtServerControl.commitWrite();

  670.         }   break;

  671. 

  672.         // int/index

  673.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  674.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  675.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  676.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  677.             fShmNonRtServerControl.writeInt(value1);

  678.             fShmNonRtServerControl.commitWrite();

  679.         }   break;

  680. 

  681.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  682.             if (value1 != 1)

  683.             {

  684.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  685.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  686.                 fShmNonRtServerControl.commitWrite();

  687.             }

  688.             break;

  689. 

  690.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

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

  692.             {

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

  694.                 {

  695.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  696. 

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

  698.                     {

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

  700. 

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

  702.                             continue;

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

  704.                             continue;

  705. 

  706.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  707.                         fShmNonRtServerControl.writeUInt(i);

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

  709.                         fShmNonRtServerControl.commitWrite();

  710. 

  711.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  712.                     }

  713.                 }

  714.             }

  715.             break;

  716. 

  717.         default:

  718.             break;

  719.         }

  720.     }

  721. 

  722.     // -------------------------------------------------------------------

  723. 

  724.     void clear() noexcept

  725.     {

  726.         fShmAudioPool.clear();

  727.         fShmRtClientControl.clear();

  728.         fShmNonRtClientControl.clear();

  729.         fShmNonRtServerControl.clear();

  730.     }

  731. 

  732.     void handleNonRtData()

  733.     {

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

  735.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  736. 

  737.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  738.         {

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

  740. 

  741. #ifdef DEBUG

  742.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  744.             }

  745. #endif

  746. 

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

  748.                 fLastPingTime = Time::currentTimeMillis();

  749. 

  750.             switch (opcode)

  751.             {

  752.             case kPluginBridgeNonRtClientNull:

  753.                 break;

  754. 

  755.             case kPluginBridgeNonRtClientVersion: {

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

  757.                 CARLA_SAFE_ASSERT_UINT2(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  758.                                         apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  759.             }   break;

  760. 

  761.             case kPluginBridgeNonRtClientPing: {

  762.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  763. 

  764.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  765.                 fShmNonRtServerControl.commitWrite();

  766.             }   break;

  767. 

  768.             case kPluginBridgeNonRtClientPingOnOff: {

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

  770. 

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

  772.             }   break;

  773. 

  774.             case kPluginBridgeNonRtClientActivate:

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

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

  777.                 break;

  778. 

  779.             case kPluginBridgeNonRtClientDeactivate:

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

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

  782.                 break;

  783. 

  784.             case kPluginBridgeNonRtClientInitialSetup:

  785.                 // should never happen!!

  786.                 fShmNonRtServerControl.readUInt();

  787.                 fShmNonRtServerControl.readDouble();

  788.                 break;

  789. 

  790.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  793. 

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

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

  796.                 break;

  797.             }

  798. 

  799.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  802. 

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

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

  805.                 break;

  806.             }

  807. 

  808.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  811. 

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

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

  814.                 break;

  815.             }

  816. 

  817.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  821. 

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

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

  824.                 break;

  825.             }

  826. 

  827.             case kPluginBridgeNonRtClientSetProgram: {

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

  829. 

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

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

  832.                 break;

  833.             }

  834. 

  835.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  837. 

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

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

  840.                 break;

  841.             }

  842. 

  843.             case kPluginBridgeNonRtClientSetCustomData: {

  844.                 // type

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

  846.                 char typeStr[typeSize+1];

  847.                 carla_zeroChars(typeStr, typeSize+1);

  848.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  849. 

  850.                 // key

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

  852.                 char keyStr[keySize+1];

  853.                 carla_zeroChars(keyStr, keySize+1);

  854.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  855. 

  856.                 // value

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

  858.                 char valueStr[valueSize+1];

  859.                 carla_zeroChars(valueStr, valueSize+1);

  860. 

  861.                 if (valueSize > 0)

  862.                     fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  863. 

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

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

  866.                 break;

  867.             }

  868. 

  869.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  871.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  872. 

  873.                 char chunkFilePathTry[size+1];

  874.                 carla_zeroChars(chunkFilePathTry, size+1);

  875.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  876. 

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

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

  879. 

  880.                 String chunkFilePath(chunkFilePathTry);

  881. 

  882. #ifdef CARLA_OS_WIN

  883.                 // check if running under Wine

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

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

  886. #endif

  887. 

  888.                 File chunkFile(chunkFilePath);

  889.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  890. 

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

  892.                 chunkFile.deleteFile();

  893.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  894. 

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

  896. 

  897. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  899. #else

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

  901. #endif

  902.                 break;

  903.             }

  904. 

  905.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  908. 

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

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

  911.                 break;

  912.             }

  913. 

  914.             case kPluginBridgeNonRtClientSetOption: {

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

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

  917. 

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

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

  920.                 break;

  921.             }

  922. 

  923.             case kPluginBridgeNonRtClientSetOptions: {

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

  925. 

  926.                 if (plugin != nullptr)

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

  928.                 break;

  929.             }

  930. 

  931.             case kPluginBridgeNonRtClientGetParameterText: {

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

  933. 

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

  935.                 {

  936.                     char bufStr[STR_MAX+1];

  937.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  940. 

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

  942. 

  943.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  944. 

  945.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  946. 

  947.                     fShmNonRtServerControl.writeInt(index);

  948.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  949.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  950.                     fShmNonRtServerControl.commitWrite();

  951. 

  952.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  953.                 }

  954. 

  955.                 break;

  956.             }

  957. 

  958.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  960.                     break;

  961. 

  962.                 plugin->prepareForSave();

  963. 

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

  965.                 {

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

  967. 

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

  969.                         continue;

  970. 

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

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

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

  974. 

  975.                     {

  976.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  977. 

  978.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  979. 

  980.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  982. 

  983.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  985. 

  986.                         fShmNonRtServerControl.writeUInt(valueLen);

  987. 

  988.                         if (valueLen > 0)

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

  990. 

  991.                         fShmNonRtServerControl.commitWrite();

  992.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  993.                     }

  994.                 }

  995. 

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

  997.                 {

  998.                     void* data = nullptr;

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

  1000.                     {

  1001.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1002. 

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

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

  1005. 

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

  1007. 

  1008.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1009.                         filePath += fShmAudioPool.getFilenameSuffix();

  1010. 

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

  1012.                         {

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

  1014. 

  1015.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1016. 

  1017.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1018.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1020.                             fShmNonRtServerControl.commitWrite();

  1021.                         }

  1022.                     }

  1023.                 }

  1024. 

  1025.                 {

  1026.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1027. 

  1028.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1029.                     fShmNonRtServerControl.commitWrite();

  1030.                 }

  1031.                 break;

  1032.             }

  1033. 

  1034.             case kPluginBridgeNonRtClientRestoreLV2State:

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

  1036.                     plugin->restoreLV2State();

  1037.                 break;

  1038. 

  1039.             case kPluginBridgeNonRtClientShowUI:

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

  1041.                     plugin->showCustomUI(true);

  1042.                 break;

  1043. 

  1044.             case kPluginBridgeNonRtClientHideUI:

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

  1046.                     plugin->showCustomUI(false);

  1047.                 break;

  1048. 

  1049.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1052. 

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

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

  1055.                 break;

  1056.             }

  1057. 

  1058.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1060. 

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

  1062.                     plugin->uiProgramChange(index);

  1063.                 break;

  1064.             }

  1065. 

  1066.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1068. 

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

  1070.                     plugin->uiMidiProgramChange(index);

  1071.                 break;

  1072.             }

  1073. 

  1074.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1078. 

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

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

  1081.                 break;

  1082.             }

  1083. 

  1084.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1087. 

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

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

  1090.                 break;

  1091.             }

  1092. 

  1093.             case kPluginBridgeNonRtClientQuit:

  1094.                 fClosingDown = true;

  1095.                 signalThreadShouldExit();

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

  1097.                 break;

  1098.             }

  1099.         }

  1100.     }

  1101. 

  1102.     // -------------------------------------------------------------------

  1103. 

  1104. protected:

  1105.     void run() override

  1106.     {

  1107. #ifdef __SSE2_MATH__

  1108.         // Set FTZ and DAZ flags

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

  1110. #endif

  1111. 

  1112.         bool quitReceived = false;

  1113. 

  1114.         for (; ! shouldThreadExit();)

  1115.         {

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

  1117. 

  1118.             if (! helper.ok)

  1119.                 continue;

  1120. 

  1121.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1122.             {

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

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

  1125. 

  1126. #ifdef DEBUG

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

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

  1129.                 }

  1130. #endif

  1131. 

  1132.                 switch (opcode)

  1133.                 {

  1134.                 case kPluginBridgeRtClientNull:

  1135.                     break;

  1136. 

  1137.                 case kPluginBridgeRtClientSetAudioPool: {

  1138.                     if (fShmAudioPool.data != nullptr)

  1139.                     {

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

  1141.                         fShmAudioPool.data = nullptr;

  1142.                     }

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

  1144.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1146.                     break;

  1147.                 }

  1148. 

  1149.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1151.                     pData->bufferSize = bufferSize;

  1152.                     bufferSizeChanged(bufferSize);

  1153.                     break;

  1154.                 }

  1155. 

  1156.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1158.                     pData->sampleRate = sampleRate;

  1159.                     sampleRateChanged(sampleRate);

  1160.                     break;

  1161.                 }

  1162. 

  1163.                 case kPluginBridgeRtClientSetOnline:

  1164.                     fIsOffline = fShmRtClientControl.readBool();

  1165.                     offlineModeChanged(fIsOffline);

  1166.                     break;

  1167. 

  1168.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1173. 

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

  1175.                     {

  1176.                         event->type    = kEngineEventTypeControl;

  1177.                         event->time    = time;

  1178.                         event->channel = channel;

  1179.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1180.                         event->ctrl.param = param;

  1181.                         event->ctrl.value = value;

  1182.                     }

  1183.                     break;

  1184.                 }

  1185. 

  1186.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1190. 

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

  1192.                     {

  1193.                         event->type    = kEngineEventTypeControl;

  1194.                         event->time    = time;

  1195.                         event->channel = channel;

  1196.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1197.                         event->ctrl.param = index;

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

  1199.                     }

  1200.                     break;

  1201.                 }

  1202. 

  1203.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1207. 

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

  1209.                     {

  1210.                         event->type    = kEngineEventTypeControl;

  1211.                         event->time    = time;

  1212.                         event->channel = channel;

  1213.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1214.                         event->ctrl.param = index;

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

  1216.                     }

  1217.                     break;

  1218.                 }

  1219. 

  1220.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1223. 

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

  1225.                     {

  1226.                         event->type    = kEngineEventTypeControl;

  1227.                         event->time    = time;

  1228.                         event->channel = channel;

  1229.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1230.                         event->ctrl.param = 0;

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

  1232.                     }

  1233.                 }   break;

  1234. 

  1235.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1238. 

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

  1240.                     {

  1241.                         event->type    = kEngineEventTypeControl;

  1242.                         event->time    = time;

  1243.                         event->channel = channel;

  1244.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1245.                         event->ctrl.param = 0;

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

  1247.                     }

  1248.                 }   break;

  1249. 

  1250.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1254.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1255. 

  1256.                     // FIXME variable-size stack

  1257.                     uint8_t data[size];

  1258. 

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

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

  1261. 

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

  1263.                     {

  1264.                         event->type    = kEngineEventTypeMidi;

  1265.                         event->time    = time;

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

  1267. 

  1268.                         event->midi.port = port;

  1269.                         event->midi.size = size;

  1270. 

  1271.                         if (size > EngineMidiEvent::kDataSize)

  1272.                         {

  1273.                             event->midi.dataExt = data;

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

  1275.                         }

  1276.                         else

  1277.                         {

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

  1279. 

  1280.                             uint8_t i=1;

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

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

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

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

  1285. 

  1286.                             event->midi.dataExt = nullptr;

  1287.                         }

  1288.                     }

  1289.                     break;

  1290.                 }

  1291. 

  1292.                 case kPluginBridgeRtClientProcess: {

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

  1294. 

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

  1296. 

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

  1298.                     {

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

  1300. 

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

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

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

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

  1305. 

  1306.                         const float* audioIn[audioInCount];

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

  1308.                         const float* cvIn[cvInCount];

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

  1310. 

  1311.                         float* fdata = fShmAudioPool.data;

  1312. 

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

  1314.                             audioIn[i] = fdata;

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

  1316.                             audioOut[i] = fdata;

  1317. 

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

  1319.                             cvIn[i] = fdata;

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

  1321.                             cvOut[i] = fdata;

  1322. 

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

  1324. 

  1325.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1326.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1327.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1329. 

  1330.                         if (timeInfo.bbt.valid)

  1331.                         {

  1332.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1333.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1334.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1335. 

  1336.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1337.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1338. 

  1339.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1340.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1341.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1342.                         }

  1343. 

  1344.                         plugin->initBuffers();

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

  1346.                         plugin->unlock();

  1347.                     }

  1348. 

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

  1350.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1351.                     std::size_t curMidiDataPos = 0;

  1352. 

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

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

  1355. 

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

  1357.                     {

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

  1359.                         {

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

  1361. 

  1362.                             if (event.type == kEngineEventTypeNull)

  1363.                                 break;

  1364. 

  1365.                             if (event.type == kEngineEventTypeControl)

  1366.                             {

  1367.                                 uint8_t data[3];

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

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

  1370. 

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

  1372.                                     break;

  1373. 

  1374.                                 // set time

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

  1376.                                 midiData = midiData + 4;

  1377.                                 curMidiDataPos += 4;

  1378. 

  1379.                                 // set port

  1380.                                 *midiData++ = 0;

  1381.                                 ++curMidiDataPos;

  1382. 

  1383.                                 // set size

  1384.                                 *midiData++ = size;

  1385.                                 ++curMidiDataPos;

  1386. 

  1387.                                 // set data

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

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

  1390. 

  1391.                                 curMidiDataPos += size;

  1392.                             }

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

  1394.                             {

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

  1396. 

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

  1398.                                     break;

  1399. 

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

  1401. 

  1402.                                 // set time

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

  1404.                                 midiData += 4;

  1405.                                 curMidiDataPos += 4;

  1406. 

  1407.                                 // set port

  1408.                                 *midiData++ = _midiEvent.port;

  1409.                                 ++curMidiDataPos;

  1410. 

  1411.                                 // set size

  1412.                                 *midiData++ = _midiEvent.size;

  1413.                                 ++curMidiDataPos;

  1414. 

  1415.                                 // set data

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

  1417. 

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

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

  1420. 

  1421.                                 curMidiDataPos += _midiEvent.size;

  1422.                             }

  1423.                         }

  1424. 

  1425.                         if (curMidiDataPos != 0 &&

  1426.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1427.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1428. 

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

  1430.                     }

  1431. 

  1432.                 }   break;

  1433. 

  1434.                 case kPluginBridgeRtClientQuit: {

  1435.                     quitReceived = true;

  1436.                     fClosingDown = true;

  1437.                     signalThreadShouldExit();

  1438.                 }   break;

  1439.                 }

  1440.             }

  1441.         }

  1442. 

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

  1444. 

  1445.         if (! quitReceived)

  1446.         {

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

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

  1449. 

  1450.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1451.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1452.             fShmNonRtServerControl.writeUInt(messageSize);

  1453.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1454.             fShmNonRtServerControl.commitWrite();

  1455.         }

  1456.     }

  1457. 

  1458.     // called from process thread above

  1459.     EngineEvent* getNextFreeInputEvent() const noexcept

  1460.     {

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

  1462.         {

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

  1464. 

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

  1466.                 return event;

  1467.         }

  1468.         return nullptr;

  1469.     }

  1470. 

  1471.     void latencyChanged(const uint32_t samples) noexcept override

  1472.     {

  1473.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1474. 

  1475.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1476.         fShmNonRtServerControl.writeUInt(samples);

  1477.         fShmNonRtServerControl.commitWrite();

  1478.     }

  1479. 

  1480.     // -------------------------------------------------------------------

  1481. 

  1482. private:

  1483.     BridgeAudioPool          fShmAudioPool;

  1484.     BridgeRtClientControl    fShmRtClientControl;

  1485.     BridgeNonRtClientControl fShmNonRtClientControl;

  1486.     BridgeNonRtServerControl fShmNonRtServerControl;

  1487. 

  1488.     CarlaString fBaseNameAudioPool;

  1489.     CarlaString fBaseNameRtClientControl;

  1490.     CarlaString fBaseNameNonRtClientControl;

  1491.     CarlaString fBaseNameNonRtServerControl;

  1492. 

  1493.     bool fClosingDown;

  1494.     bool fIsOffline;

  1495.     bool fFirstIdle;

  1496.     int64_t fLastPingTime;

  1497. 

  1498.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1499. };

  1500. 

  1501. // -----------------------------------------------------------------------

  1502. 

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

  1504. {

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

  1506. }

  1507. 

  1508. // -----------------------------------------------------------------------

  1509. 

  1510. CARLA_BACKEND_END_NAMESPACE

  1511. 

  1512. // -----------------------------------------------------------------------

  1513. 

  1514. #include "CarlaBridgeUtils.cpp"

  1515. 

  1516. // -----------------------------------------------------------------------