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

1538 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, EngineInternalGraph& egraph, CarlaPlugin* const plugin, LatencyChangedCallback* const cb)

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

  72.           fLatencyCallback(cb) {}

  73. #else

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

  75.         : CarlaEngineClientForSubclassing(engine),

  76.           fLatencyCallback(cb) {}

  77. #endif

  78. 

  79. protected:

  80.     void setLatency(const uint32_t samples) noexcept override

  81.     {

  82.         if (getLatency() == samples)

  83.             return;

  84. 

  85.         fLatencyCallback->latencyChanged(samples);

  86.         CarlaEngineClient::setLatency(samples);

  87.     }

  88. 

  89. private:

  90.     LatencyChangedCallback* const fLatencyCallback;

  91. 

  92.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  93. };

  94. 

  95. // -------------------------------------------------------------------

  96. 

  97. class CarlaEngineBridge : public CarlaEngine,

  98.                           private CarlaThread,

  99.                           private LatencyChangedCallback

  100. {

  101. public:

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

  103.         : CarlaEngine(),

  104.           CarlaThread("CarlaEngineBridge"),

  105.           fShmAudioPool(),

  106.           fShmRtClientControl(),

  107.           fShmNonRtClientControl(),

  108.           fShmNonRtServerControl(),

  109.           fBaseNameAudioPool(audioPoolBaseName),

  110.           fBaseNameRtClientControl(rtClientBaseName),

  111.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  112.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  113.           fClosingDown(false),

  114.           fIsOffline(false),

  115.           fFirstIdle(true),

  116.           fLastPingTime(-1)

  117.     {

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

  119.     }

  120. 

  121.     ~CarlaEngineBridge() noexcept override

  122.     {

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

  124. 

  125.         clear();

  126.     }

  127. 

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

  129.     // CarlaEngine virtual calls

  130. 

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

  132.     {

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

  134. 

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

  136.         {

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

  138.             return false;

  139.         }

  140. 

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

  142.         {

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

  144.             return false;

  145.         }

  146. 

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

  148.         {

  149.             clear();

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

  151.             return false;

  152.         }

  153. 

  154.         if (! fShmRtClientControl.mapData())

  155.         {

  156.             clear();

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

  158.             return false;

  159.         }

  160. 

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

  162.         {

  163.             clear();

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

  165.             return false;

  166.         }

  167. 

  168.         if (! fShmNonRtClientControl.mapData())

  169.         {

  170.             clear();

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

  172.             return false;

  173.         }

  174. 

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

  176.         {

  177.             clear();

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

  179.             return false;

  180.         }

  181. 

  182.         if (! fShmNonRtServerControl.mapData())

  183.         {

  184.             clear();

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

  186.             return false;

  187.         }

  188. 

  189.         PluginBridgeNonRtClientOpcode opcode;

  190. 

  191.         opcode = fShmNonRtClientControl.readOpcode();

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

  193. 

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

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

  196. 

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

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

  199. 

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

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

  202. 

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

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

  205. 

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

  207.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  208.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  209.         {

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

  211.             return false;

  212.         }

  213. 

  214.         opcode = fShmNonRtClientControl.readOpcode();

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

  216. 

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

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

  219. 

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

  221.         {

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

  223.             return false;

  224.         }

  225. 

  226.         pData->initTime(nullptr);

  227. 

  228.         // tell backend we're live

  229.         {

  230.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  231. 

  232.             // kPluginBridgeNonRtServerVersion was added in API 7

  233.             if (apiVersion >= 7)

  234.             {

  235.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  236.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  237.             }

  238.             else

  239.             {

  240.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  241.             }

  242. 

  243.             fShmNonRtServerControl.commitWrite();

  244.         }

  245. 

  246.         startThread(true);

  247.         return true;

  248.     }

  249. 

  250.     bool close() override

  251.     {

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

  253.         fLastPingTime = -1;

  254. 

  255.         CarlaEngine::close();

  256. 

  257.         stopThread(5000);

  258.         clear();

  259. 

  260.         return true;

  261.     }

  262. 

  263.     bool isRunning() const noexcept override

  264.     {

  265.         if (fClosingDown)

  266.             return false;

  267. 

  268.         return isThreadRunning() || ! fFirstIdle;

  269.     }

  270. 

  271.     bool isOffline() const noexcept override

  272.     {

  273.         return fIsOffline;

  274.     }

  275. 

  276.     EngineType getType() const noexcept override

  277.     {

  278.         return kEngineTypeBridge;

  279.     }

  280. 

  281.     const char* getCurrentDriverName() const noexcept override

  282.     {

  283.         return "Bridge";

  284.     }

  285. 

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

  287.     {

  288.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  289. 

  290.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  291.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  292.         fShmNonRtServerControl.writeUInt(parameterId);

  293.         fShmNonRtServerControl.writeBool(touch);

  294.         fShmNonRtServerControl.commitWrite();

  295.     }

  296. 

  297.     CarlaEngineClient* addClient(CarlaPlugin* const plugin) override

  298.     {

  299. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  301. #else

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

  303. 

  304.         // unused

  305.         (void)plugin;

  306. #endif

  307.     }

  308. 

  309.     void idle() noexcept override

  310.     {

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

  312. 

  313.         if (plugin == nullptr)

  314.         {

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

  316.             {

  317.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  318.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  319.                 fShmNonRtServerControl.writeUInt(length);

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

  321.                 fShmNonRtServerControl.commitWrite();

  322.             }

  323. 

  324.             signalThreadShouldExit();

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

  326.             return;

  327.         }

  328. 

  329.         const bool wasFirstIdle(fFirstIdle);

  330. 

  331.         if (wasFirstIdle)

  332.         {

  333.             fFirstIdle = false;

  334.             fLastPingTime = Time::currentTimeMillis();

  335.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  336. 

  337.             char bufStr[STR_MAX+1];

  338.             carla_zeroChars(bufStr, STR_MAX+1);

  339. 

  340.             uint32_t bufStrSize;

  341. 

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

  343.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  344. 

  345.             // kPluginBridgeNonRtServerPluginInfo1

  346.             {

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

  348.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  354.                 fShmNonRtServerControl.commitWrite();

  355.             }

  356. 

  357.             // kPluginBridgeNonRtServerPluginInfo2

  358.             {

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

  360.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  361. 

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

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

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

  365.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  366.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  367. 

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

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

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

  371.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  372.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  373. 

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

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

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

  377.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  378.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  379. 

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

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

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

  383.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  384.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  385. 

  386.                 fShmNonRtServerControl.commitWrite();

  387.             }

  388. 

  389.             // kPluginBridgeNonRtServerAudioCount

  390.             {

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

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

  393. 

  394.                 // uint/ins, uint/outs

  395.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  396.                 fShmNonRtServerControl.writeUInt(aIns);

  397.                 fShmNonRtServerControl.writeUInt(aOuts);

  398.                 fShmNonRtServerControl.commitWrite();

  399. 

  400.                 // kPluginBridgeNonRtServerPortName

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

  402.                 {

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

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

  405. 

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

  407.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  408.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  409.                     fShmNonRtServerControl.writeUInt(i);

  410. 

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

  412.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  413.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  414.                 }

  415. 

  416.                 // kPluginBridgeNonRtServerPortName

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

  418.                 {

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

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

  421. 

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

  423.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  424.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  425.                     fShmNonRtServerControl.writeUInt(i);

  426. 

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

  428.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  429.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  430.                 }

  431.             }

  432. 

  433.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  434. 

  435.             // kPluginBridgeNonRtServerMidiCount

  436.             {

  437.                 // uint/ins, uint/outs

  438.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  441.                 fShmNonRtServerControl.commitWrite();

  442.             }

  443. 

  444.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  445. 

  446.             // kPluginBridgeNonRtServerCvCount

  447.             {

  448.                 // uint/ins, uint/outs

  449.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  452.                 fShmNonRtServerControl.commitWrite();

  453.             }

  454. 

  455.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  456. 

  457.             // kPluginBridgeNonRtServerParameter*

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

  459.             {

  460.                 // uint/count

  461.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  462.                 fShmNonRtServerControl.writeUInt(count);

  463.                 fShmNonRtServerControl.commitWrite();

  464. 

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

  466.                 {

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

  468. 

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

  470.                         continue;

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

  472.                         continue;

  473. 

  474.                     // kPluginBridgeNonRtServerParameterData1

  475.                     {

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

  477.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  478.                         fShmNonRtServerControl.writeUInt(i);

  479.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  480.                         fShmNonRtServerControl.writeUInt(paramData.type);

  481.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  482.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  483.                         fShmNonRtServerControl.commitWrite();

  484.                     }

  485. 

  486.                     // kPluginBridgeNonRtServerParameterData2

  487.                     {

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

  489.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  490.                         fShmNonRtServerControl.writeUInt(i);

  491. 

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

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

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

  495.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  496.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  497. 

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

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

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

  501.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  502.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  503. 

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

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

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

  507.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  508.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  509. 

  510.                         fShmNonRtServerControl.commitWrite();

  511.                     }

  512. 

  513.                     // kPluginBridgeNonRtServerParameterRanges

  514.                     {

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

  516. 

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

  518.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  519.                         fShmNonRtServerControl.writeUInt(i);

  520.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  521.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  522.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  523.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  524.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  525.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  526.                         fShmNonRtServerControl.commitWrite();

  527.                     }

  528. 

  529.                     // kPluginBridgeNonRtServerParameterValue2

  530.                     {

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

  532.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  533.                         fShmNonRtServerControl.writeUInt(i);

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

  535.                         fShmNonRtServerControl.commitWrite();

  536.                     }

  537. 

  538.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  539.                 }

  540.             }

  541. 

  542.             // kPluginBridgeNonRtServerProgram*

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

  544.             {

  545.                 // uint/count

  546.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  547.                 fShmNonRtServerControl.writeUInt(count);

  548.                 fShmNonRtServerControl.commitWrite();

  549. 

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

  551.                 {

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

  553.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  554.                     fShmNonRtServerControl.writeUInt(i);

  555. 

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

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

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

  559.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  560.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  561. 

  562.                     fShmNonRtServerControl.commitWrite();

  563.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  564.                 }

  565.             }

  566. 

  567.             // kPluginBridgeNonRtServerMidiProgram*

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

  569.             {

  570.                 // uint/count

  571.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  572.                 fShmNonRtServerControl.writeUInt(count);

  573.                 fShmNonRtServerControl.commitWrite();

  574. 

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

  576.                 {

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

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

  579. 

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

  581.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  582.                     fShmNonRtServerControl.writeUInt(i);

  583.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  584.                     fShmNonRtServerControl.writeUInt(mpData.program);

  585. 

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

  587.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  589. 

  590.                     fShmNonRtServerControl.commitWrite();

  591.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  592.                 }

  593.             }

  594. 

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

  596.             {

  597.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  598.                 fShmNonRtServerControl.writeUInt(latency);

  599.                 fShmNonRtServerControl.commitWrite();

  600.             }

  601. 

  602.             // ready!

  603.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  604.             fShmNonRtServerControl.commitWrite();

  605.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  606. 

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

  608.             fLastPingTime = Time::currentTimeMillis();

  609.         }

  610. 

  611.         // send parameter outputs

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

  613.         {

  614.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  615. 

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

  617.             {

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

  619.                     continue;

  620. 

  621.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  622.                 fShmNonRtServerControl.writeUInt(i);

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

  624. 

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

  626.                 if (! fShmNonRtServerControl.commitWrite())

  627.                     break;

  628.             }

  629.         }

  630. 

  631.         CarlaEngine::idle();

  632. 

  633.         try {

  634.             handleNonRtData();

  635.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  636. 

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

  638.         {

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

  640.             signalThreadShouldExit();

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

  642.         }

  643.     }

  644. 

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

  646.                   const EngineCallbackOpcode action, const uint pluginId,

  647.                   const int value1, const int value2, const int value3,

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

  649.     {

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

  651. 

  652.         if (fClosingDown || ! sendHost)

  653.             return;

  654. 

  655.         switch (action)

  656.         {

  657.         // uint/index float/value

  658.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  659.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  660.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  661.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  663.             fShmNonRtServerControl.writeFloat(valuef);

  664.             fShmNonRtServerControl.commitWrite();

  665.         }   break;

  666. 

  667.         // uint/index float/value

  668.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  669.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  670.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  671.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  673.             fShmNonRtServerControl.writeFloat(valuef);

  674.             fShmNonRtServerControl.commitWrite();

  675.         }   break;

  676. 

  677.         // int/index

  678.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  679.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  680.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  681.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  682.             fShmNonRtServerControl.writeInt(value1);

  683.             fShmNonRtServerControl.commitWrite();

  684.         }   break;

  685. 

  686.         // int/index

  687.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  688.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  689.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  690.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  691.             fShmNonRtServerControl.writeInt(value1);

  692.             fShmNonRtServerControl.commitWrite();

  693.         }   break;

  694. 

  695.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  696.             if (value1 != 1)

  697.             {

  698.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  699.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  700.                 fShmNonRtServerControl.commitWrite();

  701.             }

  702.             break;

  703. 

  704.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

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

  706.             {

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

  708.                 {

  709.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  710. 

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

  712.                     {

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

  714. 

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

  716.                             continue;

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

  718.                             continue;

  719. 

  720.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  721.                         fShmNonRtServerControl.writeUInt(i);

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

  723.                         fShmNonRtServerControl.commitWrite();

  724. 

  725.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  726.                     }

  727.                 }

  728.             }

  729.             break;

  730. 

  731.         default:

  732.             break;

  733.         }

  734.     }

  735. 

  736.     // -------------------------------------------------------------------

  737. 

  738.     void clear() noexcept

  739.     {

  740.         fShmAudioPool.clear();

  741.         fShmRtClientControl.clear();

  742.         fShmNonRtClientControl.clear();

  743.         fShmNonRtServerControl.clear();

  744.     }

  745. 

  746.     void handleNonRtData()

  747.     {

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

  749.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  750. 

  751.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  752.         {

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

  754. 

  755. #ifdef DEBUG

  756.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  758.             }

  759. #endif

  760. 

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

  762.                 fLastPingTime = Time::currentTimeMillis();

  763. 

  764.             switch (opcode)

  765.             {

  766.             case kPluginBridgeNonRtClientNull:

  767.                 break;

  768. 

  769.             case kPluginBridgeNonRtClientVersion: {

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

  771.                 CARLA_SAFE_ASSERT_UINT2(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  772.                                         apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  773.             }   break;

  774. 

  775.             case kPluginBridgeNonRtClientPing: {

  776.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  777. 

  778.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  779.                 fShmNonRtServerControl.commitWrite();

  780.             }   break;

  781. 

  782.             case kPluginBridgeNonRtClientPingOnOff: {

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

  784. 

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

  786.             }   break;

  787. 

  788.             case kPluginBridgeNonRtClientActivate:

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

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

  791.                 break;

  792. 

  793.             case kPluginBridgeNonRtClientDeactivate:

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

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

  796.                 break;

  797. 

  798.             case kPluginBridgeNonRtClientInitialSetup:

  799.                 // should never happen!!

  800.                 fShmNonRtServerControl.readUInt();

  801.                 fShmNonRtServerControl.readDouble();

  802.                 break;

  803. 

  804.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  807. 

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

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

  810.                 break;

  811.             }

  812. 

  813.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  816. 

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

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

  819.                 break;

  820.             }

  821. 

  822.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

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

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

  825. 

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

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

  828.                 break;

  829.             }

  830. 

  831.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  835. 

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

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

  838.                 break;

  839.             }

  840. 

  841.             case kPluginBridgeNonRtClientSetProgram: {

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

  843. 

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

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

  846.                 break;

  847.             }

  848. 

  849.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  851. 

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

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

  854.                 break;

  855.             }

  856. 

  857.             case kPluginBridgeNonRtClientSetCustomData: {

  858.                 // type

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

  860.                 char typeStr[typeSize+1];

  861.                 carla_zeroChars(typeStr, typeSize+1);

  862.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  863. 

  864.                 // key

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

  866.                 char keyStr[keySize+1];

  867.                 carla_zeroChars(keyStr, keySize+1);

  868.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  869. 

  870.                 // value

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

  872.                 char valueStr[valueSize+1];

  873.                 carla_zeroChars(valueStr, valueSize+1);

  874. 

  875.                 if (valueSize > 0)

  876.                     fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  877. 

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

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

  880.                 break;

  881.             }

  882. 

  883.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  885.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  886. 

  887.                 char chunkFilePathTry[size+1];

  888.                 carla_zeroChars(chunkFilePathTry, size+1);

  889.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  890. 

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

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

  893. 

  894.                 String chunkFilePath(chunkFilePathTry);

  895. 

  896. #ifdef CARLA_OS_WIN

  897.                 // check if running under Wine

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

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

  900. #endif

  901. 

  902.                 File chunkFile(chunkFilePath);

  903.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  904. 

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

  906.                 chunkFile.deleteFile();

  907.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  908. 

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

  910. 

  911. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  913. #else

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

  915. #endif

  916.                 break;

  917.             }

  918. 

  919.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  922. 

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

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

  925.                 break;

  926.             }

  927. 

  928.             case kPluginBridgeNonRtClientSetOption: {

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

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

  931. 

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

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

  934.                 break;

  935.             }

  936. 

  937.             case kPluginBridgeNonRtClientSetOptions: {

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

  939. 

  940.                 if (plugin != nullptr)

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

  942.                 break;

  943.             }

  944. 

  945.             case kPluginBridgeNonRtClientGetParameterText: {

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

  947. 

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

  949.                 {

  950.                     char bufStr[STR_MAX+1];

  951.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  954. 

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

  956. 

  957.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  958. 

  959.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  960. 

  961.                     fShmNonRtServerControl.writeInt(index);

  962.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  963.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  964.                     fShmNonRtServerControl.commitWrite();

  965. 

  966.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  967.                 }

  968. 

  969.                 break;

  970.             }

  971. 

  972.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  974.                     break;

  975. 

  976.                 plugin->prepareForSave();

  977. 

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

  979.                 {

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

  981. 

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

  983.                         continue;

  984. 

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

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

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

  988. 

  989.                     {

  990.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  991. 

  992.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  993. 

  994.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  996. 

  997.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  999. 

  1000.                         fShmNonRtServerControl.writeUInt(valueLen);

  1001. 

  1002.                         if (valueLen > 0)

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

  1004. 

  1005.                         fShmNonRtServerControl.commitWrite();

  1006.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1007.                     }

  1008.                 }

  1009. 

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

  1011.                 {

  1012.                     void* data = nullptr;

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

  1014.                     {

  1015.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1016. 

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

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

  1019. 

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

  1021. 

  1022.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1023.                         filePath += fShmAudioPool.getFilenameSuffix();

  1024. 

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

  1026.                         {

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

  1028. 

  1029.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1030. 

  1031.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1032.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1034.                             fShmNonRtServerControl.commitWrite();

  1035.                         }

  1036.                     }

  1037.                 }

  1038. 

  1039.                 {

  1040.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1041. 

  1042.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1043.                     fShmNonRtServerControl.commitWrite();

  1044.                 }

  1045.                 break;

  1046.             }

  1047. 

  1048.             case kPluginBridgeNonRtClientRestoreLV2State:

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

  1050.                     plugin->restoreLV2State();

  1051.                 break;

  1052. 

  1053.             case kPluginBridgeNonRtClientShowUI:

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

  1055.                     plugin->showCustomUI(true);

  1056.                 break;

  1057. 

  1058.             case kPluginBridgeNonRtClientHideUI:

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

  1060.                     plugin->showCustomUI(false);

  1061.                 break;

  1062. 

  1063.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1066. 

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

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

  1069.                 break;

  1070.             }

  1071. 

  1072.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1074. 

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

  1076.                     plugin->uiProgramChange(index);

  1077.                 break;

  1078.             }

  1079. 

  1080.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1082. 

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

  1084.                     plugin->uiMidiProgramChange(index);

  1085.                 break;

  1086.             }

  1087. 

  1088.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1092. 

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

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

  1095.                 break;

  1096.             }

  1097. 

  1098.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1101. 

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

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

  1104.                 break;

  1105.             }

  1106. 

  1107.             case kPluginBridgeNonRtClientQuit:

  1108.                 fClosingDown = true;

  1109.                 signalThreadShouldExit();

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

  1111.                 break;

  1112.             }

  1113.         }

  1114.     }

  1115. 

  1116.     // -------------------------------------------------------------------

  1117. 

  1118. protected:

  1119.     void run() override

  1120.     {

  1121. #ifdef __SSE2_MATH__

  1122.         // Set FTZ and DAZ flags

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

  1124. #endif

  1125. 

  1126.         bool quitReceived = false;

  1127. 

  1128.         for (; ! shouldThreadExit();)

  1129.         {

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

  1131. 

  1132.             if (! helper.ok)

  1133.                 continue;

  1134. 

  1135.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1136.             {

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

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

  1139. 

  1140. #ifdef DEBUG

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

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

  1143.                 }

  1144. #endif

  1145. 

  1146.                 switch (opcode)

  1147.                 {

  1148.                 case kPluginBridgeRtClientNull:

  1149.                     break;

  1150. 

  1151.                 case kPluginBridgeRtClientSetAudioPool: {

  1152.                     if (fShmAudioPool.data != nullptr)

  1153.                     {

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

  1155.                         fShmAudioPool.data = nullptr;

  1156.                     }

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

  1158.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1160.                     break;

  1161.                 }

  1162. 

  1163.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1165.                     pData->bufferSize = bufferSize;

  1166.                     bufferSizeChanged(bufferSize);

  1167.                     break;

  1168.                 }

  1169. 

  1170.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1172.                     pData->sampleRate = sampleRate;

  1173.                     sampleRateChanged(sampleRate);

  1174.                     break;

  1175.                 }

  1176. 

  1177.                 case kPluginBridgeRtClientSetOnline:

  1178.                     fIsOffline = fShmRtClientControl.readBool();

  1179.                     offlineModeChanged(fIsOffline);

  1180.                     break;

  1181. 

  1182.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1187. 

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

  1189.                     {

  1190.                         event->type    = kEngineEventTypeControl;

  1191.                         event->time    = time;

  1192.                         event->channel = channel;

  1193.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1194.                         event->ctrl.param = param;

  1195.                         event->ctrl.value = value;

  1196.                     }

  1197.                     break;

  1198.                 }

  1199. 

  1200.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1204. 

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

  1206.                     {

  1207.                         event->type    = kEngineEventTypeControl;

  1208.                         event->time    = time;

  1209.                         event->channel = channel;

  1210.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1211.                         event->ctrl.param = index;

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

  1213.                     }

  1214.                     break;

  1215.                 }

  1216. 

  1217.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1221. 

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

  1223.                     {

  1224.                         event->type    = kEngineEventTypeControl;

  1225.                         event->time    = time;

  1226.                         event->channel = channel;

  1227.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1228.                         event->ctrl.param = index;

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

  1230.                     }

  1231.                     break;

  1232.                 }

  1233. 

  1234.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1237. 

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

  1239.                     {

  1240.                         event->type    = kEngineEventTypeControl;

  1241.                         event->time    = time;

  1242.                         event->channel = channel;

  1243.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1244.                         event->ctrl.param = 0;

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

  1246.                     }

  1247.                 }   break;

  1248. 

  1249.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1252. 

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

  1254.                     {

  1255.                         event->type    = kEngineEventTypeControl;

  1256.                         event->time    = time;

  1257.                         event->channel = channel;

  1258.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1259.                         event->ctrl.param = 0;

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

  1261.                     }

  1262.                 }   break;

  1263. 

  1264.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1268.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1269. 

  1270.                     // FIXME variable-size stack

  1271.                     uint8_t data[size];

  1272. 

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

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

  1275. 

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

  1277.                     {

  1278.                         event->type    = kEngineEventTypeMidi;

  1279.                         event->time    = time;

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

  1281. 

  1282.                         event->midi.port = port;

  1283.                         event->midi.size = size;

  1284. 

  1285.                         if (size > EngineMidiEvent::kDataSize)

  1286.                         {

  1287.                             event->midi.dataExt = data;

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

  1289.                         }

  1290.                         else

  1291.                         {

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

  1293. 

  1294.                             uint8_t i=1;

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

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

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

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

  1299. 

  1300.                             event->midi.dataExt = nullptr;

  1301.                         }

  1302.                     }

  1303.                     break;

  1304.                 }

  1305. 

  1306.                 case kPluginBridgeRtClientProcess: {

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

  1308. 

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

  1310. 

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

  1312.                     {

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

  1314. 

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

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

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

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

  1319. 

  1320.                         const float* audioIn[audioInCount];

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

  1322.                         const float* cvIn[cvInCount];

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

  1324. 

  1325.                         float* fdata = fShmAudioPool.data;

  1326. 

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

  1328.                             audioIn[i] = fdata;

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

  1330.                             audioOut[i] = fdata;

  1331. 

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

  1333.                             cvIn[i] = fdata;

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

  1335.                             cvOut[i] = fdata;

  1336. 

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

  1338. 

  1339.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1340.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1341.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1343. 

  1344.                         if (timeInfo.bbt.valid)

  1345.                         {

  1346.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1347.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1348.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1349. 

  1350.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1351.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1352. 

  1353.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1354.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1355.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1356.                         }

  1357. 

  1358.                         plugin->initBuffers();

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

  1360.                         plugin->unlock();

  1361.                     }

  1362. 

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

  1364.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1365.                     std::size_t curMidiDataPos = 0;

  1366. 

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

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

  1369. 

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

  1371.                     {

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

  1373.                         {

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

  1375. 

  1376.                             if (event.type == kEngineEventTypeNull)

  1377.                                 break;

  1378. 

  1379.                             if (event.type == kEngineEventTypeControl)

  1380.                             {

  1381.                                 uint8_t data[3];

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

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

  1384. 

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

  1386.                                     break;

  1387. 

  1388.                                 // set time

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

  1390.                                 midiData = midiData + 4;

  1391.                                 curMidiDataPos += 4;

  1392. 

  1393.                                 // set port

  1394.                                 *midiData++ = 0;

  1395.                                 ++curMidiDataPos;

  1396. 

  1397.                                 // set size

  1398.                                 *midiData++ = size;

  1399.                                 ++curMidiDataPos;

  1400. 

  1401.                                 // set data

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

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

  1404. 

  1405.                                 curMidiDataPos += size;

  1406.                             }

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

  1408.                             {

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

  1410. 

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

  1412.                                     break;

  1413. 

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

  1415. 

  1416.                                 // set time

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

  1418.                                 midiData += 4;

  1419.                                 curMidiDataPos += 4;

  1420. 

  1421.                                 // set port

  1422.                                 *midiData++ = _midiEvent.port;

  1423.                                 ++curMidiDataPos;

  1424. 

  1425.                                 // set size

  1426.                                 *midiData++ = _midiEvent.size;

  1427.                                 ++curMidiDataPos;

  1428. 

  1429.                                 // set data

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

  1431. 

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

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

  1434. 

  1435.                                 curMidiDataPos += _midiEvent.size;

  1436.                             }

  1437.                         }

  1438. 

  1439.                         if (curMidiDataPos != 0 &&

  1440.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1441.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1442. 

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

  1444.                     }

  1445. 

  1446.                 }   break;

  1447. 

  1448.                 case kPluginBridgeRtClientQuit: {

  1449.                     quitReceived = true;

  1450.                     fClosingDown = true;

  1451.                     signalThreadShouldExit();

  1452.                 }   break;

  1453.                 }

  1454.             }

  1455.         }

  1456. 

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

  1458. 

  1459.         if (! quitReceived)

  1460.         {

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

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

  1463. 

  1464.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1465.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1466.             fShmNonRtServerControl.writeUInt(messageSize);

  1467.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1468.             fShmNonRtServerControl.commitWrite();

  1469.         }

  1470.     }

  1471. 

  1472.     // called from process thread above

  1473.     EngineEvent* getNextFreeInputEvent() const noexcept

  1474.     {

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

  1476.         {

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

  1478. 

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

  1480.                 return event;

  1481.         }

  1482.         return nullptr;

  1483.     }

  1484. 

  1485.     void latencyChanged(const uint32_t samples) noexcept override

  1486.     {

  1487.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1488. 

  1489.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1490.         fShmNonRtServerControl.writeUInt(samples);

  1491.         fShmNonRtServerControl.commitWrite();

  1492.     }

  1493. 

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

  1495. 

  1496. private:

  1497.     BridgeAudioPool          fShmAudioPool;

  1498.     BridgeRtClientControl    fShmRtClientControl;

  1499.     BridgeNonRtClientControl fShmNonRtClientControl;

  1500.     BridgeNonRtServerControl fShmNonRtServerControl;

  1501. 

  1502.     CarlaString fBaseNameAudioPool;

  1503.     CarlaString fBaseNameRtClientControl;

  1504.     CarlaString fBaseNameNonRtClientControl;

  1505.     CarlaString fBaseNameNonRtServerControl;

  1506. 

  1507.     bool fClosingDown;

  1508.     bool fIsOffline;

  1509.     bool fFirstIdle;

  1510.     int64_t fLastPingTime;

  1511. 

  1512.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1513. };

  1514. 

  1515. // -----------------------------------------------------------------------

  1516. 

  1517. namespace EngineInit {

  1518. 

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

  1520.                        const char* const rtClientBaseName,

  1521.                        const char* const nonRtClientBaseName,

  1522.                        const char* const nonRtServerBaseName)

  1523. {

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

  1525. }

  1526. 

  1527. }

  1528. 

  1529. // -----------------------------------------------------------------------

  1530. 

  1531. CARLA_BACKEND_END_NAMESPACE

  1532. 

  1533. // -----------------------------------------------------------------------

  1534. 

  1535. #include "CarlaBridgeUtils.cpp"

  1536. 

  1537. // -----------------------------------------------------------------------