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

1540 lines
61KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2020 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 "CarlaEngineClient.hpp"

  23. #include "CarlaEngineInit.hpp"

  24. #include "CarlaPlugin.hpp"

  25. 

  26. #include "CarlaBackendUtils.hpp"

  27. #include "CarlaBase64Utils.hpp"

  28. #include "CarlaBridgeUtils.hpp"

  29. #include "CarlaMIDI.h"

  30. 

  31. #ifdef __SSE2_MATH__

  32. # include <xmmintrin.h>

  33. #endif

  34. 

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

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

  37. 

  38. // must be last

  39. #include "jackbridge/JackBridge.hpp"

  40. 

  41. using water::File;

  42. using water::MemoryBlock;

  43. using water::String;

  44. using water::Time;

  45. 

  46. CARLA_BACKEND_START_NAMESPACE

  47. 

  48. // -----------------------------------------------------------------------

  49. 

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

  51. struct CarlaPlugin::ProtectedData {

  52.     CarlaEngine* const engine;

  53.     CarlaEngineClient* client;

  54.     uint id, hints, options;

  55.     // ...etc

  56. };

  57. 

  58. // -----------------------------------------------------------------------

  59. // Bridge Engine client

  60. 

  61. struct LatencyChangedCallback {

  62.     virtual ~LatencyChangedCallback() noexcept {}

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

  64. };

  65. 

  66. class CarlaEngineBridgeClient : public CarlaEngineClientForSubclassing

  67. {

  68. public:

  69. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  70.     CarlaEngineBridgeClient(const CarlaEngine& engine,

  71.                             EngineInternalGraph& egraph,

  72.                             const CarlaPluginPtr plugin,

  73.                             LatencyChangedCallback* const cb)

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

  75.           fLatencyCallback(cb) {}

  76. #else

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

  78.         : CarlaEngineClientForSubclassing(engine),

  79.           fLatencyCallback(cb) {}

  80. #endif

  81. 

  82. protected:

  83.     void setLatency(const uint32_t samples) noexcept override

  84.     {

  85.         if (getLatency() == samples)

  86.             return;

  87. 

  88.         fLatencyCallback->latencyChanged(samples);

  89.         CarlaEngineClient::setLatency(samples);

  90.     }

  91. 

  92. private:

  93.     LatencyChangedCallback* const fLatencyCallback;

  94. 

  95.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  96. };

  97. 

  98. // -------------------------------------------------------------------

  99. 

  100. class CarlaEngineBridge : public CarlaEngine,

  101.                           private CarlaThread,

  102.                           private LatencyChangedCallback

  103. {

  104. public:

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

  106.         : CarlaEngine(),

  107.           CarlaThread("CarlaEngineBridge"),

  108.           fShmAudioPool(),

  109.           fShmRtClientControl(),

  110.           fShmNonRtClientControl(),

  111.           fShmNonRtServerControl(),

  112.           fBaseNameAudioPool(audioPoolBaseName),

  113.           fBaseNameRtClientControl(rtClientBaseName),

  114.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  115.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  116.           fClosingDown(false),

  117.           fIsOffline(false),

  118.           fFirstIdle(true),

  119.           fLastPingTime(-1)

  120.     {

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

  122.     }

  123. 

  124.     ~CarlaEngineBridge() noexcept override

  125.     {

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

  127. 

  128.         clear();

  129.     }

  130. 

  131.     // -------------------------------------

  132.     // CarlaEngine virtual calls

  133. 

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

  135.     {

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

  137. 

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

  139.         {

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

  141.             return false;

  142.         }

  143. 

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

  145.         {

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

  147.             return false;

  148.         }

  149. 

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

  151.         {

  152.             clear();

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

  154.             return false;

  155.         }

  156. 

  157.         if (! fShmRtClientControl.mapData())

  158.         {

  159.             clear();

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

  161.             return false;

  162.         }

  163. 

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

  165.         {

  166.             clear();

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

  168.             return false;

  169.         }

  170. 

  171.         if (! fShmNonRtClientControl.mapData())

  172.         {

  173.             clear();

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

  175.             return false;

  176.         }

  177. 

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

  179.         {

  180.             clear();

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

  182.             return false;

  183.         }

  184. 

  185.         if (! fShmNonRtServerControl.mapData())

  186.         {

  187.             clear();

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

  189.             return false;

  190.         }

  191. 

  192.         PluginBridgeNonRtClientOpcode opcode;

  193. 

  194.         opcode = fShmNonRtClientControl.readOpcode();

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

  196. 

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

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

  199. 

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

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

  202. 

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

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

  205. 

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

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

  208. 

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

  210.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  211.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  212.         {

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

  214.             return false;

  215.         }

  216. 

  217.         opcode = fShmNonRtClientControl.readOpcode();

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

  219. 

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

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

  222. 

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

  224.         {

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

  226.             return false;

  227.         }

  228. 

  229.         pData->initTime(nullptr);

  230. 

  231.         // tell backend we're live

  232.         {

  233.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  234. 

  235.             // kPluginBridgeNonRtServerVersion was added in API 7

  236.             if (apiVersion >= 7)

  237.             {

  238.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  239.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  240.             }

  241.             else

  242.             {

  243.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  244.             }

  245. 

  246.             fShmNonRtServerControl.commitWrite();

  247.         }

  248. 

  249.         startThread(true);

  250.         return true;

  251.     }

  252. 

  253.     bool close() override

  254.     {

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

  256.         fLastPingTime = -1;

  257. 

  258.         CarlaEngine::close();

  259. 

  260.         stopThread(5000);

  261.         clear();

  262. 

  263.         return true;

  264.     }

  265. 

  266.     bool isRunning() const noexcept override

  267.     {

  268.         if (fClosingDown)

  269.             return false;

  270. 

  271.         return isThreadRunning() || ! fFirstIdle;

  272.     }

  273. 

  274.     bool isOffline() const noexcept override

  275.     {

  276.         return fIsOffline;

  277.     }

  278. 

  279.     EngineType getType() const noexcept override

  280.     {

  281.         return kEngineTypeBridge;

  282.     }

  283. 

  284.     const char* getCurrentDriverName() const noexcept override

  285.     {

  286.         return "Bridge";

  287.     }

  288. 

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

  290.     {

  291.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  292. 

  293.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  294.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  295.         fShmNonRtServerControl.writeUInt(parameterId);

  296.         fShmNonRtServerControl.writeBool(touch);

  297.         fShmNonRtServerControl.commitWrite();

  298.     }

  299. 

  300.     CarlaEngineClient* addClient(const CarlaPluginPtr plugin) override

  301.     {

  302. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  304. #else

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

  306. 

  307.         // unused

  308.         (void)plugin;

  309. #endif

  310.     }

  311. 

  312.     void idle() noexcept override

  313.     {

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

  315. 

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

  317.         {

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

  319.             {

  320.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  321.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  322.                 fShmNonRtServerControl.writeUInt(length);

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

  324.                 fShmNonRtServerControl.commitWrite();

  325.             }

  326. 

  327.             signalThreadShouldExit();

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

  329.             return;

  330.         }

  331. 

  332.         const bool wasFirstIdle(fFirstIdle);

  333. 

  334.         if (wasFirstIdle)

  335.         {

  336.             fFirstIdle = false;

  337.             fLastPingTime = Time::currentTimeMillis();

  338.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  339. 

  340.             char bufStr[STR_MAX+1];

  341.             carla_zeroChars(bufStr, STR_MAX+1);

  342. 

  343.             uint32_t bufStrSize;

  344. 

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

  346.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  347. 

  348.             // kPluginBridgeNonRtServerPluginInfo1

  349.             {

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

  351.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  357.                 fShmNonRtServerControl.commitWrite();

  358.             }

  359. 

  360.             // kPluginBridgeNonRtServerPluginInfo2

  361.             {

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

  363.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  364. 

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

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

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

  368.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  369.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  370. 

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

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

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

  374.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  375.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  376. 

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

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

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

  380.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  381.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  382. 

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

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

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

  386.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  387.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  388. 

  389.                 fShmNonRtServerControl.commitWrite();

  390.             }

  391. 

  392.             // kPluginBridgeNonRtServerAudioCount

  393.             {

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

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

  396. 

  397.                 // uint/ins, uint/outs

  398.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  399.                 fShmNonRtServerControl.writeUInt(aIns);

  400.                 fShmNonRtServerControl.writeUInt(aOuts);

  401.                 fShmNonRtServerControl.commitWrite();

  402. 

  403.                 // kPluginBridgeNonRtServerPortName

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

  405.                 {

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

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

  408. 

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

  410.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  411.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  412.                     fShmNonRtServerControl.writeUInt(i);

  413. 

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

  415.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  416.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  417.                 }

  418. 

  419.                 // kPluginBridgeNonRtServerPortName

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

  421.                 {

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

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

  424. 

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

  426.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  427.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  428.                     fShmNonRtServerControl.writeUInt(i);

  429. 

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

  431.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  432.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  433.                 }

  434.             }

  435. 

  436.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  437. 

  438.             // kPluginBridgeNonRtServerMidiCount

  439.             {

  440.                 // uint/ins, uint/outs

  441.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  444.                 fShmNonRtServerControl.commitWrite();

  445.             }

  446. 

  447.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  448. 

  449.             // kPluginBridgeNonRtServerCvCount

  450.             {

  451.                 // uint/ins, uint/outs

  452.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  455.                 fShmNonRtServerControl.commitWrite();

  456.             }

  457. 

  458.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  459. 

  460.             // kPluginBridgeNonRtServerParameter*

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

  462.             {

  463.                 // uint/count

  464.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  465.                 fShmNonRtServerControl.writeUInt(count);

  466.                 fShmNonRtServerControl.commitWrite();

  467. 

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

  469.                 {

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

  471. 

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

  473.                         continue;

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

  475.                         continue;

  476. 

  477.                     // kPluginBridgeNonRtServerParameterData1

  478.                     {

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

  480.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  481.                         fShmNonRtServerControl.writeUInt(i);

  482.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  483.                         fShmNonRtServerControl.writeUInt(paramData.type);

  484.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  485.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  486.                         fShmNonRtServerControl.commitWrite();

  487.                     }

  488. 

  489.                     // kPluginBridgeNonRtServerParameterData2

  490.                     {

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

  492.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  493.                         fShmNonRtServerControl.writeUInt(i);

  494. 

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

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

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

  498.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  499.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  500. 

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

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

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

  504.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  505.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  506. 

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

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

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

  510.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  511.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  512. 

  513.                         fShmNonRtServerControl.commitWrite();

  514.                     }

  515. 

  516.                     // kPluginBridgeNonRtServerParameterRanges

  517.                     {

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

  519. 

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

  521.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  522.                         fShmNonRtServerControl.writeUInt(i);

  523.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  524.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  525.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  526.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  527.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  528.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  529.                         fShmNonRtServerControl.commitWrite();

  530.                     }

  531. 

  532.                     // kPluginBridgeNonRtServerParameterValue2

  533.                     {

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

  535.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  536.                         fShmNonRtServerControl.writeUInt(i);

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

  538.                         fShmNonRtServerControl.commitWrite();

  539.                     }

  540. 

  541.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  542.                 }

  543.             }

  544. 

  545.             // kPluginBridgeNonRtServerProgram*

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

  547.             {

  548.                 // uint/count

  549.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  550.                 fShmNonRtServerControl.writeUInt(count);

  551.                 fShmNonRtServerControl.commitWrite();

  552. 

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

  554.                 {

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

  556.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  557.                     fShmNonRtServerControl.writeUInt(i);

  558. 

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

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

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

  562.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  563.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  564. 

  565.                     fShmNonRtServerControl.commitWrite();

  566.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  567.                 }

  568.             }

  569. 

  570.             // kPluginBridgeNonRtServerMidiProgram*

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

  572.             {

  573.                 // uint/count

  574.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  575.                 fShmNonRtServerControl.writeUInt(count);

  576.                 fShmNonRtServerControl.commitWrite();

  577. 

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

  579.                 {

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

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

  582. 

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

  584.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  585.                     fShmNonRtServerControl.writeUInt(i);

  586.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  587.                     fShmNonRtServerControl.writeUInt(mpData.program);

  588. 

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

  590.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  592. 

  593.                     fShmNonRtServerControl.commitWrite();

  594.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  595.                 }

  596.             }

  597. 

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

  599.             {

  600.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  601.                 fShmNonRtServerControl.writeUInt(latency);

  602.                 fShmNonRtServerControl.commitWrite();

  603.             }

  604. 

  605.             // ready!

  606.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  607.             fShmNonRtServerControl.commitWrite();

  608.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  609. 

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

  611.             fLastPingTime = Time::currentTimeMillis();

  612.         }

  613. 

  614.         // send parameter outputs

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

  616.         {

  617.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  618. 

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

  620.             {

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

  622.                     continue;

  623. 

  624.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  625.                 fShmNonRtServerControl.writeUInt(i);

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

  627. 

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

  629.                 if (! fShmNonRtServerControl.commitWrite())

  630.                     break;

  631.             }

  632.         }

  633. 

  634.         CarlaEngine::idle();

  635. 

  636.         try {

  637.             handleNonRtData();

  638.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  639. 

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

  641.         {

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

  643.             signalThreadShouldExit();

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

  645.         }

  646.     }

  647. 

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

  649.                   const EngineCallbackOpcode action, const uint pluginId,

  650.                   const int value1, const int value2, const int value3,

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

  652.     {

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

  654. 

  655.         if (fClosingDown || ! sendHost)

  656.             return;

  657. 

  658.         switch (action)

  659.         {

  660.         // uint/index float/value

  661.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  662.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  663.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  664.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  666.             fShmNonRtServerControl.writeFloat(valuef);

  667.             fShmNonRtServerControl.commitWrite();

  668.         }   break;

  669. 

  670.         // uint/index float/value

  671.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  672.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  673.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  674.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  676.             fShmNonRtServerControl.writeFloat(valuef);

  677.             fShmNonRtServerControl.commitWrite();

  678.         }   break;

  679. 

  680.         // int/index

  681.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  682.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  683.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  684.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  685.             fShmNonRtServerControl.writeInt(value1);

  686.             fShmNonRtServerControl.commitWrite();

  687.         }   break;

  688. 

  689.         // int/index

  690.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  691.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  692.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  693.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  694.             fShmNonRtServerControl.writeInt(value1);

  695.             fShmNonRtServerControl.commitWrite();

  696.         }   break;

  697. 

  698.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  699.             if (value1 != 1)

  700.             {

  701.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  702.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  703.                 fShmNonRtServerControl.commitWrite();

  704.             }

  705.             break;

  706. 

  707.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

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

  709.             {

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

  711.                 {

  712.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  713. 

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

  715.                     {

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

  717. 

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

  719.                             continue;

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

  721.                             continue;

  722. 

  723.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  724.                         fShmNonRtServerControl.writeUInt(i);

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

  726.                         fShmNonRtServerControl.commitWrite();

  727. 

  728.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  729.                     }

  730.                 }

  731.             }

  732.             break;

  733. 

  734.         default:

  735.             break;

  736.         }

  737.     }

  738. 

  739.     // -------------------------------------------------------------------

  740. 

  741.     void clear() noexcept

  742.     {

  743.         fShmAudioPool.clear();

  744.         fShmRtClientControl.clear();

  745.         fShmNonRtClientControl.clear();

  746.         fShmNonRtServerControl.clear();

  747.     }

  748. 

  749.     void handleNonRtData()

  750.     {

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

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

  753. 

  754.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  755.         {

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

  757. 

  758. #ifdef DEBUG

  759.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  761.             }

  762. #endif

  763. 

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

  765.                 fLastPingTime = Time::currentTimeMillis();

  766. 

  767.             switch (opcode)

  768.             {

  769.             case kPluginBridgeNonRtClientNull:

  770.                 break;

  771. 

  772.             case kPluginBridgeNonRtClientVersion: {

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

  774.                 CARLA_SAFE_ASSERT_UINT2(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  775.                                         apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  776.             }   break;

  777. 

  778.             case kPluginBridgeNonRtClientPing: {

  779.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  780. 

  781.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  782.                 fShmNonRtServerControl.commitWrite();

  783.             }   break;

  784. 

  785.             case kPluginBridgeNonRtClientPingOnOff: {

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

  787. 

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

  789.             }   break;

  790. 

  791.             case kPluginBridgeNonRtClientActivate:

  792.                 if (plugin->isEnabled())

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

  794.                 break;

  795. 

  796.             case kPluginBridgeNonRtClientDeactivate:

  797.                 if (plugin->isEnabled())

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

  799.                 break;

  800. 

  801.             case kPluginBridgeNonRtClientInitialSetup:

  802.                 // should never happen!!

  803.                 fShmNonRtServerControl.readUInt();

  804.                 fShmNonRtServerControl.readDouble();

  805.                 break;

  806. 

  807.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  810. 

  811.                 if (plugin->isEnabled())

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

  813.                 break;

  814.             }

  815. 

  816.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  819. 

  820.                 if (plugin->isEnabled())

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

  822.                 break;

  823.             }

  824. 

  825.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

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

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

  828. 

  829.                 if (plugin->isEnabled())

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

  831.                 break;

  832.             }

  833. 

  834.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  838. 

  839.                 if (plugin->isEnabled())

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

  841.                 break;

  842.             }

  843. 

  844.             case kPluginBridgeNonRtClientSetProgram: {

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

  846. 

  847.                 if (plugin->isEnabled())

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

  849.                 break;

  850.             }

  851. 

  852.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  854. 

  855.                 if (plugin->isEnabled())

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

  857.                 break;

  858.             }

  859. 

  860.             case kPluginBridgeNonRtClientSetCustomData: {

  861.                 // type

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

  863.                 char typeStr[typeSize+1];

  864.                 carla_zeroChars(typeStr, typeSize+1);

  865.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  866. 

  867.                 // key

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

  869.                 char keyStr[keySize+1];

  870.                 carla_zeroChars(keyStr, keySize+1);

  871.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  872. 

  873.                 // value

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

  875.                 char valueStr[valueSize+1];

  876.                 carla_zeroChars(valueStr, valueSize+1);

  877. 

  878.                 if (valueSize > 0)

  879.                     fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  880. 

  881.                 if (plugin->isEnabled())

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

  883.                 break;

  884.             }

  885. 

  886.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  888.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  889. 

  890.                 char chunkFilePathTry[size+1];

  891.                 carla_zeroChars(chunkFilePathTry, size+1);

  892.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  893. 

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

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

  896. 

  897.                 String chunkFilePath(chunkFilePathTry);

  898. 

  899. #ifdef CARLA_OS_WIN

  900.                 // check if running under Wine

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

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

  903. #endif

  904. 

  905.                 File chunkFile(chunkFilePath);

  906.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  907. 

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

  909.                 chunkFile.deleteFile();

  910.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  911. 

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

  913. 

  914. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  916. #else

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

  918. #endif

  919.                 break;

  920.             }

  921. 

  922.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  925. 

  926.                 if (plugin->isEnabled())

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

  928.                 break;

  929.             }

  930. 

  931.             case kPluginBridgeNonRtClientSetOption: {

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

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

  934. 

  935.                 if (plugin->isEnabled())

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

  937.                 break;

  938.             }

  939. 

  940.             case kPluginBridgeNonRtClientSetOptions: {

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

  942. 

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

  944.                 break;

  945.             }

  946. 

  947.             case kPluginBridgeNonRtClientGetParameterText: {

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

  949. 

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

  951.                 {

  952.                     char bufStr[STR_MAX+1];

  953.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  956. 

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

  958. 

  959.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  960. 

  961.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  962. 

  963.                     fShmNonRtServerControl.writeInt(index);

  964.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  965.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  966.                     fShmNonRtServerControl.commitWrite();

  967. 

  968.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  969.                 }

  970. 

  971.                 break;

  972.             }

  973. 

  974.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  976.                     break;

  977. 

  978.                 plugin->prepareForSave();

  979. 

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

  981.                 {

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

  983. 

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

  985.                         continue;

  986. 

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

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

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

  990. 

  991.                     {

  992.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  993. 

  994.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  995. 

  996.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  998. 

  999.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1001. 

  1002.                         fShmNonRtServerControl.writeUInt(valueLen);

  1003. 

  1004.                         if (valueLen > 0)

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

  1006. 

  1007.                         fShmNonRtServerControl.commitWrite();

  1008.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1009.                     }

  1010.                 }

  1011. 

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

  1013.                 {

  1014.                     void* data = nullptr;

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

  1016.                     {

  1017.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1018. 

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

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

  1021. 

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

  1023. 

  1024.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1025.                         filePath += fShmAudioPool.getFilenameSuffix();

  1026. 

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

  1028.                         {

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

  1030. 

  1031.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1032. 

  1033.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1034.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1036.                             fShmNonRtServerControl.commitWrite();

  1037.                         }

  1038.                     }

  1039.                 }

  1040. 

  1041.                 {

  1042.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1043. 

  1044.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1045.                     fShmNonRtServerControl.commitWrite();

  1046.                 }

  1047.                 break;

  1048.             }

  1049. 

  1050.             case kPluginBridgeNonRtClientRestoreLV2State:

  1051.                 if (plugin->isEnabled())

  1052.                     plugin->restoreLV2State();

  1053.                 break;

  1054. 

  1055.             case kPluginBridgeNonRtClientShowUI:

  1056.                 if (plugin->isEnabled())

  1057.                     plugin->showCustomUI(true);

  1058.                 break;

  1059. 

  1060.             case kPluginBridgeNonRtClientHideUI:

  1061.                 if (plugin->isEnabled())

  1062.                     plugin->showCustomUI(false);

  1063.                 break;

  1064. 

  1065.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1068. 

  1069.                 if (plugin->isEnabled())

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

  1071.                 break;

  1072.             }

  1073. 

  1074.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1076. 

  1077.                 if (plugin->isEnabled())

  1078.                     plugin->uiProgramChange(index);

  1079.                 break;

  1080.             }

  1081. 

  1082.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1084. 

  1085.                 if (plugin->isEnabled())

  1086.                     plugin->uiMidiProgramChange(index);

  1087.                 break;

  1088.             }

  1089. 

  1090.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1094. 

  1095.                 if (plugin->isEnabled())

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

  1097.                 break;

  1098.             }

  1099. 

  1100.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1103. 

  1104.                 if (plugin->isEnabled())

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

  1106.                 break;

  1107.             }

  1108. 

  1109.             case kPluginBridgeNonRtClientQuit:

  1110.                 fClosingDown = true;

  1111.                 signalThreadShouldExit();

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

  1113.                 break;

  1114.             }

  1115.         }

  1116.     }

  1117. 

  1118.     // -------------------------------------------------------------------

  1119. 

  1120. protected:

  1121.     void run() override

  1122.     {

  1123. #ifdef __SSE2_MATH__

  1124.         // Set FTZ and DAZ flags

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

  1126. #endif

  1127. 

  1128.         bool quitReceived = false;

  1129. 

  1130.         for (; ! shouldThreadExit();)

  1131.         {

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

  1133. 

  1134.             if (! helper.ok)

  1135.                 continue;

  1136. 

  1137.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1138.             {

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

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

  1141. 

  1142. #ifdef DEBUG

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

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

  1145.                 }

  1146. #endif

  1147. 

  1148.                 switch (opcode)

  1149.                 {

  1150.                 case kPluginBridgeRtClientNull:

  1151.                     break;

  1152. 

  1153.                 case kPluginBridgeRtClientSetAudioPool: {

  1154.                     if (fShmAudioPool.data != nullptr)

  1155.                     {

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

  1157.                         fShmAudioPool.data = nullptr;

  1158.                     }

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

  1160.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1162.                     break;

  1163.                 }

  1164. 

  1165.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1167.                     pData->bufferSize = bufferSize;

  1168.                     bufferSizeChanged(bufferSize);

  1169.                     break;

  1170.                 }

  1171. 

  1172.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1174.                     pData->sampleRate = sampleRate;

  1175.                     sampleRateChanged(sampleRate);

  1176.                     break;

  1177.                 }

  1178. 

  1179.                 case kPluginBridgeRtClientSetOnline:

  1180.                     fIsOffline = fShmRtClientControl.readBool();

  1181.                     offlineModeChanged(fIsOffline);

  1182.                     break;

  1183. 

  1184.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1189. 

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

  1191.                     {

  1192.                         event->type    = kEngineEventTypeControl;

  1193.                         event->time    = time;

  1194.                         event->channel = channel;

  1195.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1196.                         event->ctrl.param = param;

  1197.                         event->ctrl.value = value;

  1198.                     }

  1199.                     break;

  1200.                 }

  1201. 

  1202.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1206. 

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

  1208.                     {

  1209.                         event->type    = kEngineEventTypeControl;

  1210.                         event->time    = time;

  1211.                         event->channel = channel;

  1212.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1213.                         event->ctrl.param = index;

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

  1215.                     }

  1216.                     break;

  1217.                 }

  1218. 

  1219.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1223. 

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

  1225.                     {

  1226.                         event->type    = kEngineEventTypeControl;

  1227.                         event->time    = time;

  1228.                         event->channel = channel;

  1229.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1230.                         event->ctrl.param = index;

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

  1232.                     }

  1233.                     break;

  1234.                 }

  1235. 

  1236.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1239. 

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

  1241.                     {

  1242.                         event->type    = kEngineEventTypeControl;

  1243.                         event->time    = time;

  1244.                         event->channel = channel;

  1245.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1246.                         event->ctrl.param = 0;

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

  1248.                     }

  1249.                 }   break;

  1250. 

  1251.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1254. 

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

  1256.                     {

  1257.                         event->type    = kEngineEventTypeControl;

  1258.                         event->time    = time;

  1259.                         event->channel = channel;

  1260.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1261.                         event->ctrl.param = 0;

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

  1263.                     }

  1264.                 }   break;

  1265. 

  1266.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1270.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1271. 

  1272.                     // FIXME variable-size stack

  1273.                     uint8_t data[size];

  1274. 

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

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

  1277. 

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

  1279.                     {

  1280.                         event->type    = kEngineEventTypeMidi;

  1281.                         event->time    = time;

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

  1283. 

  1284.                         event->midi.port = port;

  1285.                         event->midi.size = size;

  1286. 

  1287.                         if (size > EngineMidiEvent::kDataSize)

  1288.                         {

  1289.                             event->midi.dataExt = data;

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

  1291.                         }

  1292.                         else

  1293.                         {

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

  1295. 

  1296.                             uint8_t i=1;

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

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

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

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

  1301. 

  1302.                             event->midi.dataExt = nullptr;

  1303.                         }

  1304.                     }

  1305.                     break;

  1306.                 }

  1307. 

  1308.                 case kPluginBridgeRtClientProcess: {

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

  1310. 

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

  1312. 

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

  1314.                     {

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

  1316. 

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

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

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

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

  1321. 

  1322.                         const float* audioIn[audioInCount];

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

  1324.                         const float* cvIn[cvInCount];

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

  1326. 

  1327.                         float* fdata = fShmAudioPool.data;

  1328. 

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

  1330.                             audioIn[i] = fdata;

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

  1332.                             audioOut[i] = fdata;

  1333. 

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

  1335.                             cvIn[i] = fdata;

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

  1337.                             cvOut[i] = fdata;

  1338. 

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

  1340. 

  1341.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1342.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1343.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1345. 

  1346.                         if (timeInfo.bbt.valid)

  1347.                         {

  1348.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1349.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1350.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1351. 

  1352.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1353.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1354. 

  1355.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1356.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1357.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1358.                         }

  1359. 

  1360.                         plugin->initBuffers();

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

  1362.                         plugin->unlock();

  1363.                     }

  1364. 

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

  1366.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1367.                     std::size_t curMidiDataPos = 0;

  1368. 

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

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

  1371. 

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

  1373.                     {

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

  1375.                         {

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

  1377. 

  1378.                             if (event.type == kEngineEventTypeNull)

  1379.                                 break;

  1380. 

  1381.                             if (event.type == kEngineEventTypeControl)

  1382.                             {

  1383.                                 uint8_t data[3];

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

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

  1386. 

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

  1388.                                     break;

  1389. 

  1390.                                 // set time

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

  1392.                                 midiData = midiData + 4;

  1393.                                 curMidiDataPos += 4;

  1394. 

  1395.                                 // set port

  1396.                                 *midiData++ = 0;

  1397.                                 ++curMidiDataPos;

  1398. 

  1399.                                 // set size

  1400.                                 *midiData++ = size;

  1401.                                 ++curMidiDataPos;

  1402. 

  1403.                                 // set data

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

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

  1406. 

  1407.                                 curMidiDataPos += size;

  1408.                             }

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

  1410.                             {

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

  1412. 

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

  1414.                                     break;

  1415. 

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

  1417. 

  1418.                                 // set time

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

  1420.                                 midiData += 4;

  1421.                                 curMidiDataPos += 4;

  1422. 

  1423.                                 // set port

  1424.                                 *midiData++ = _midiEvent.port;

  1425.                                 ++curMidiDataPos;

  1426. 

  1427.                                 // set size

  1428.                                 *midiData++ = _midiEvent.size;

  1429.                                 ++curMidiDataPos;

  1430. 

  1431.                                 // set data

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

  1433. 

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

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

  1436. 

  1437.                                 curMidiDataPos += _midiEvent.size;

  1438.                             }

  1439.                         }

  1440. 

  1441.                         if (curMidiDataPos != 0 &&

  1442.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1443.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1444. 

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

  1446.                     }

  1447. 

  1448.                 }   break;

  1449. 

  1450.                 case kPluginBridgeRtClientQuit: {

  1451.                     quitReceived = true;

  1452.                     fClosingDown = true;

  1453.                     signalThreadShouldExit();

  1454.                 }   break;

  1455.                 }

  1456.             }

  1457.         }

  1458. 

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

  1460. 

  1461.         if (! quitReceived)

  1462.         {

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

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

  1465. 

  1466.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1467.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1468.             fShmNonRtServerControl.writeUInt(messageSize);

  1469.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1470.             fShmNonRtServerControl.commitWrite();

  1471.         }

  1472.     }

  1473. 

  1474.     // called from process thread above

  1475.     EngineEvent* getNextFreeInputEvent() const noexcept

  1476.     {

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

  1478.         {

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

  1480. 

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

  1482.                 return event;

  1483.         }

  1484.         return nullptr;

  1485.     }

  1486. 

  1487.     void latencyChanged(const uint32_t samples) noexcept override

  1488.     {

  1489.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1490. 

  1491.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1492.         fShmNonRtServerControl.writeUInt(samples);

  1493.         fShmNonRtServerControl.commitWrite();

  1494.     }

  1495. 

  1496.     // -------------------------------------------------------------------

  1497. 

  1498. private:

  1499.     BridgeAudioPool          fShmAudioPool;

  1500.     BridgeRtClientControl    fShmRtClientControl;

  1501.     BridgeNonRtClientControl fShmNonRtClientControl;

  1502.     BridgeNonRtServerControl fShmNonRtServerControl;

  1503. 

  1504.     CarlaString fBaseNameAudioPool;

  1505.     CarlaString fBaseNameRtClientControl;

  1506.     CarlaString fBaseNameNonRtClientControl;

  1507.     CarlaString fBaseNameNonRtServerControl;

  1508. 

  1509.     bool fClosingDown;

  1510.     bool fIsOffline;

  1511.     bool fFirstIdle;

  1512.     int64_t fLastPingTime;

  1513. 

  1514.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1515. };

  1516. 

  1517. // -----------------------------------------------------------------------

  1518. 

  1519. namespace EngineInit {

  1520. 

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

  1522.                        const char* const rtClientBaseName,

  1523.                        const char* const nonRtClientBaseName,

  1524.                        const char* const nonRtServerBaseName)

  1525. {

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

  1527. }

  1528. 

  1529. }

  1530. 

  1531. // -----------------------------------------------------------------------

  1532. 

  1533. CARLA_BACKEND_END_NAMESPACE

  1534. 

  1535. // -----------------------------------------------------------------------

  1536. 

  1537. #include "CarlaBridgeUtils.cpp"

  1538. 

  1539. // -----------------------------------------------------------------------