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

1530 lines
61KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #ifndef BUILD_BRIDGE

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

  20. #endif

  21. 

  22. #include "CarlaEngineClient.hpp"

  23. #include "CarlaPlugin.hpp"

  24. 

  25. #include "CarlaBackendUtils.hpp"

  26. #include "CarlaBase64Utils.hpp"

  27. #include "CarlaBridgeUtils.hpp"

  28. #include "CarlaMIDI.h"

  29. 

  30. #ifdef __SSE2_MATH__

  31. # include <xmmintrin.h>

  32. #endif

  33. 

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

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

  36. 

  37. // must be last

  38. #include "jackbridge/JackBridge.hpp"

  39. 

  40. using water::File;

  41. using water::MemoryBlock;

  42. using water::String;

  43. using water::Time;

  44. 

  45. CARLA_BACKEND_START_NAMESPACE

  46. 

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

  48. 

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

  50. struct CarlaPlugin::ProtectedData {

  51.     CarlaEngine* const engine;

  52.     CarlaEngineClient* client;

  53.     uint id, hints, options;

  54.     // ...etc

  55. };

  56. 

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

  58. // Bridge Engine client

  59. 

  60. struct LatencyChangedCallback {

  61.     virtual ~LatencyChangedCallback() noexcept {}

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

  63. };

  64. 

  65. class CarlaEngineBridgeClient : public CarlaEngineClientForSubclassing

  66. {

  67. public:

  68. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  69.     CarlaEngineBridgeClient(const CarlaEngine& engine, EngineInternalGraph& egraph, CarlaPlugin* const plugin, LatencyChangedCallback* const cb)

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

  71.           fLatencyCallback(cb) {}

  72. #else

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

  74.         : CarlaEngineClientForSubclassing(engine),

  75.           fLatencyCallback(cb) {}

  76. #endif

  77. 

  78. protected:

  79.     void setLatency(const uint32_t samples) noexcept override

  80.     {

  81.         if (getLatency() == samples)

  82.             return;

  83. 

  84.         fLatencyCallback->latencyChanged(samples);

  85.         CarlaEngineClient::setLatency(samples);

  86.     }

  87. 

  88. private:

  89.     LatencyChangedCallback* const fLatencyCallback;

  90. 

  91.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  92. };

  93. 

  94. // -------------------------------------------------------------------

  95. 

  96. class CarlaEngineBridge : public CarlaEngine,

  97.                           private CarlaThread,

  98.                           private LatencyChangedCallback

  99. {

  100. public:

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

  102.         : CarlaEngine(),

  103.           CarlaThread("CarlaEngineBridge"),

  104.           fShmAudioPool(),

  105.           fShmRtClientControl(),

  106.           fShmNonRtClientControl(),

  107.           fShmNonRtServerControl(),

  108.           fBaseNameAudioPool(audioPoolBaseName),

  109.           fBaseNameRtClientControl(rtClientBaseName),

  110.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  111.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  112.           fClosingDown(false),

  113.           fIsOffline(false),

  114.           fFirstIdle(true),

  115.           fLastPingTime(-1)

  116.     {

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

  118.     }

  119. 

  120.     ~CarlaEngineBridge() noexcept override

  121.     {

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

  123. 

  124.         clear();

  125.     }

  126. 

  127.     // -------------------------------------

  128.     // CarlaEngine virtual calls

  129. 

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

  131.     {

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

  133. 

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

  135.         {

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

  137.             return false;

  138.         }

  139. 

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

  141.         {

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

  143.             return false;

  144.         }

  145. 

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

  147.         {

  148.             clear();

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

  150.             return false;

  151.         }

  152. 

  153.         if (! fShmRtClientControl.mapData())

  154.         {

  155.             clear();

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

  157.             return false;

  158.         }

  159. 

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

  161.         {

  162.             clear();

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

  164.             return false;

  165.         }

  166. 

  167.         if (! fShmNonRtClientControl.mapData())

  168.         {

  169.             clear();

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

  171.             return false;

  172.         }

  173. 

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

  175.         {

  176.             clear();

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

  178.             return false;

  179.         }

  180. 

  181.         if (! fShmNonRtServerControl.mapData())

  182.         {

  183.             clear();

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

  185.             return false;

  186.         }

  187. 

  188.         PluginBridgeNonRtClientOpcode opcode;

  189. 

  190.         opcode = fShmNonRtClientControl.readOpcode();

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

  192. 

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

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

  195. 

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

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

  198. 

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

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

  201. 

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

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

  204. 

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

  206.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  207.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  208.         {

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

  210.             return false;

  211.         }

  212. 

  213.         opcode = fShmNonRtClientControl.readOpcode();

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

  215. 

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

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

  218. 

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

  220.         {

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

  222.             return false;

  223.         }

  224. 

  225.         pData->initTime(nullptr);

  226. 

  227.         // tell backend we're live

  228.         {

  229.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  230. 

  231.             // kPluginBridgeNonRtServerVersion was added in API 7

  232.             if (apiVersion >= 7)

  233.             {

  234.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  235.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  236.             }

  237.             else

  238.             {

  239.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  240.             }

  241. 

  242.             fShmNonRtServerControl.commitWrite();

  243.         }

  244. 

  245.         startThread(true);

  246.         return true;

  247.     }

  248. 

  249.     bool close() override

  250.     {

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

  252.         fLastPingTime = -1;

  253. 

  254.         CarlaEngine::close();

  255. 

  256.         stopThread(5000);

  257.         clear();

  258. 

  259.         return true;

  260.     }

  261. 

  262.     bool isRunning() const noexcept override

  263.     {

  264.         if (fClosingDown)

  265.             return false;

  266. 

  267.         return isThreadRunning() || ! fFirstIdle;

  268.     }

  269. 

  270.     bool isOffline() const noexcept override

  271.     {

  272.         return fIsOffline;

  273.     }

  274. 

  275.     EngineType getType() const noexcept override

  276.     {

  277.         return kEngineTypeBridge;

  278.     }

  279. 

  280.     const char* getCurrentDriverName() const noexcept override

  281.     {

  282.         return "Bridge";

  283.     }

  284. 

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

  286.     {

  287.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  288. 

  289.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  290.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  291.         fShmNonRtServerControl.writeUInt(parameterId);

  292.         fShmNonRtServerControl.writeBool(touch);

  293.         fShmNonRtServerControl.commitWrite();

  294.     }

  295. 

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

  297.     {

  298. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  300. #else

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

  302. 

  303.         // unused

  304.         (void)plugin;

  305. #endif

  306.     }

  307. 

  308.     void idle() noexcept override

  309.     {

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

  311. 

  312.         if (plugin == nullptr)

  313.         {

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

  315.             {

  316.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  317.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  318.                 fShmNonRtServerControl.writeUInt(length);

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

  320.                 fShmNonRtServerControl.commitWrite();

  321.             }

  322. 

  323.             signalThreadShouldExit();

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

  325.             return;

  326.         }

  327. 

  328.         const bool wasFirstIdle(fFirstIdle);

  329. 

  330.         if (wasFirstIdle)

  331.         {

  332.             fFirstIdle = false;

  333.             fLastPingTime = Time::currentTimeMillis();

  334.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  335. 

  336.             char bufStr[STR_MAX+1];

  337.             carla_zeroChars(bufStr, STR_MAX+1);

  338. 

  339.             uint32_t bufStrSize;

  340. 

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

  342.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  343. 

  344.             // kPluginBridgeNonRtServerPluginInfo1

  345.             {

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

  347.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  353.                 fShmNonRtServerControl.commitWrite();

  354.             }

  355. 

  356.             // kPluginBridgeNonRtServerPluginInfo2

  357.             {

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

  359.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  360. 

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

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

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

  364.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  365.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  366. 

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

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

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

  370.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  371.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  372. 

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

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

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

  376.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  377.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  378. 

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

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

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

  382.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  383.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  384. 

  385.                 fShmNonRtServerControl.commitWrite();

  386.             }

  387. 

  388.             // kPluginBridgeNonRtServerAudioCount

  389.             {

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

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

  392. 

  393.                 // uint/ins, uint/outs

  394.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  395.                 fShmNonRtServerControl.writeUInt(aIns);

  396.                 fShmNonRtServerControl.writeUInt(aOuts);

  397.                 fShmNonRtServerControl.commitWrite();

  398. 

  399.                 // kPluginBridgeNonRtServerPortName

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

  401.                 {

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

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

  404. 

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

  406.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  407.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  408.                     fShmNonRtServerControl.writeUInt(i);

  409. 

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

  411.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  412.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  413.                 }

  414. 

  415.                 // kPluginBridgeNonRtServerPortName

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

  417.                 {

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

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

  420. 

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

  422.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  423.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  424.                     fShmNonRtServerControl.writeUInt(i);

  425. 

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

  427.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  428.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  429.                 }

  430.             }

  431. 

  432.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  433. 

  434.             // kPluginBridgeNonRtServerMidiCount

  435.             {

  436.                 // uint/ins, uint/outs

  437.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  440.                 fShmNonRtServerControl.commitWrite();

  441.             }

  442. 

  443.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  444. 

  445.             // kPluginBridgeNonRtServerCvCount

  446.             {

  447.                 // uint/ins, uint/outs

  448.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  451.                 fShmNonRtServerControl.commitWrite();

  452.             }

  453. 

  454.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  455. 

  456.             // kPluginBridgeNonRtServerParameter*

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

  458.             {

  459.                 // uint/count

  460.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  461.                 fShmNonRtServerControl.writeUInt(count);

  462.                 fShmNonRtServerControl.commitWrite();

  463. 

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

  465.                 {

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

  467. 

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

  469.                         continue;

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

  471.                         continue;

  472. 

  473.                     // kPluginBridgeNonRtServerParameterData1

  474.                     {

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

  476.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  477.                         fShmNonRtServerControl.writeUInt(i);

  478.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  479.                         fShmNonRtServerControl.writeUInt(paramData.type);

  480.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  481.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  482.                         fShmNonRtServerControl.commitWrite();

  483.                     }

  484. 

  485.                     // kPluginBridgeNonRtServerParameterData2

  486.                     {

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

  488.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  489.                         fShmNonRtServerControl.writeUInt(i);

  490. 

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

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

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

  494.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  495.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  496. 

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

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

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

  500.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  501.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  502. 

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

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

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

  506.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  507.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  508. 

  509.                         fShmNonRtServerControl.commitWrite();

  510.                     }

  511. 

  512.                     // kPluginBridgeNonRtServerParameterRanges

  513.                     {

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

  515. 

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

  517.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  518.                         fShmNonRtServerControl.writeUInt(i);

  519.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  520.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  521.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  522.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  523.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  524.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  525.                         fShmNonRtServerControl.commitWrite();

  526.                     }

  527. 

  528.                     // kPluginBridgeNonRtServerParameterValue2

  529.                     {

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

  531.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  532.                         fShmNonRtServerControl.writeUInt(i);

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

  534.                         fShmNonRtServerControl.commitWrite();

  535.                     }

  536. 

  537.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  538.                 }

  539.             }

  540. 

  541.             // kPluginBridgeNonRtServerProgram*

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

  543.             {

  544.                 // uint/count

  545.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  546.                 fShmNonRtServerControl.writeUInt(count);

  547.                 fShmNonRtServerControl.commitWrite();

  548. 

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

  550.                 {

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

  552.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  553.                     fShmNonRtServerControl.writeUInt(i);

  554. 

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

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

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

  558.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  559.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  560. 

  561.                     fShmNonRtServerControl.commitWrite();

  562.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  563.                 }

  564.             }

  565. 

  566.             // kPluginBridgeNonRtServerMidiProgram*

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

  568.             {

  569.                 // uint/count

  570.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  571.                 fShmNonRtServerControl.writeUInt(count);

  572.                 fShmNonRtServerControl.commitWrite();

  573. 

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

  575.                 {

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

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

  578. 

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

  580.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  581.                     fShmNonRtServerControl.writeUInt(i);

  582.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  583.                     fShmNonRtServerControl.writeUInt(mpData.program);

  584. 

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

  586.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  588. 

  589.                     fShmNonRtServerControl.commitWrite();

  590.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  591.                 }

  592.             }

  593. 

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

  595.             {

  596.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  597.                 fShmNonRtServerControl.writeUInt(latency);

  598.                 fShmNonRtServerControl.commitWrite();

  599.             }

  600. 

  601.             // ready!

  602.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  603.             fShmNonRtServerControl.commitWrite();

  604.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  605. 

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

  607.             fLastPingTime = Time::currentTimeMillis();

  608.         }

  609. 

  610.         // send parameter outputs

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

  612.         {

  613.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  614. 

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

  616.             {

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

  618.                     continue;

  619. 

  620.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  621.                 fShmNonRtServerControl.writeUInt(i);

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

  623. 

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

  625.                 if (! fShmNonRtServerControl.commitWrite())

  626.                     break;

  627.             }

  628.         }

  629. 

  630.         CarlaEngine::idle();

  631. 

  632.         try {

  633.             handleNonRtData();

  634.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  635. 

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

  637.         {

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

  639.             signalThreadShouldExit();

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

  641.         }

  642.     }

  643. 

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

  645.                   const EngineCallbackOpcode action, const uint pluginId,

  646.                   const int value1, const int value2, const int value3,

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

  648.     {

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

  650. 

  651.         if (fClosingDown || ! sendHost)

  652.             return;

  653. 

  654.         switch (action)

  655.         {

  656.         // uint/index float/value

  657.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  658.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  659.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  660.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  662.             fShmNonRtServerControl.writeFloat(valuef);

  663.             fShmNonRtServerControl.commitWrite();

  664.         }   break;

  665. 

  666.         // uint/index float/value

  667.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  668.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  669.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  670.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  672.             fShmNonRtServerControl.writeFloat(valuef);

  673.             fShmNonRtServerControl.commitWrite();

  674.         }   break;

  675. 

  676.         // int/index

  677.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  678.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  679.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  680.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  681.             fShmNonRtServerControl.writeInt(value1);

  682.             fShmNonRtServerControl.commitWrite();

  683.         }   break;

  684. 

  685.         // int/index

  686.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  687.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  688.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  689.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  690.             fShmNonRtServerControl.writeInt(value1);

  691.             fShmNonRtServerControl.commitWrite();

  692.         }   break;

  693. 

  694.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  695.             if (value1 != 1)

  696.             {

  697.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  698.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  699.                 fShmNonRtServerControl.commitWrite();

  700.             }

  701.             break;

  702. 

  703.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

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

  705.             {

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

  707.                 {

  708.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  709. 

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

  711.                     {

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

  713. 

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

  715.                             continue;

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

  717.                             continue;

  718. 

  719.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  720.                         fShmNonRtServerControl.writeUInt(i);

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

  722.                         fShmNonRtServerControl.commitWrite();

  723. 

  724.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  725.                     }

  726.                 }

  727.             }

  728.             break;

  729. 

  730.         default:

  731.             break;

  732.         }

  733.     }

  734. 

  735.     // -------------------------------------------------------------------

  736. 

  737.     void clear() noexcept

  738.     {

  739.         fShmAudioPool.clear();

  740.         fShmRtClientControl.clear();

  741.         fShmNonRtClientControl.clear();

  742.         fShmNonRtServerControl.clear();

  743.     }

  744. 

  745.     void handleNonRtData()

  746.     {

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

  748.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  749. 

  750.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  751.         {

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

  753. 

  754. #ifdef DEBUG

  755.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  757.             }

  758. #endif

  759. 

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

  761.                 fLastPingTime = Time::currentTimeMillis();

  762. 

  763.             switch (opcode)

  764.             {

  765.             case kPluginBridgeNonRtClientNull:

  766.                 break;

  767. 

  768.             case kPluginBridgeNonRtClientVersion: {

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

  770.                 CARLA_SAFE_ASSERT_UINT2(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  771.                                         apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  772.             }   break;

  773. 

  774.             case kPluginBridgeNonRtClientPing: {

  775.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  776. 

  777.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  778.                 fShmNonRtServerControl.commitWrite();

  779.             }   break;

  780. 

  781.             case kPluginBridgeNonRtClientPingOnOff: {

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

  783. 

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

  785.             }   break;

  786. 

  787.             case kPluginBridgeNonRtClientActivate:

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

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

  790.                 break;

  791. 

  792.             case kPluginBridgeNonRtClientDeactivate:

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

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

  795.                 break;

  796. 

  797.             case kPluginBridgeNonRtClientInitialSetup:

  798.                 // should never happen!!

  799.                 fShmNonRtServerControl.readUInt();

  800.                 fShmNonRtServerControl.readDouble();

  801.                 break;

  802. 

  803.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  806. 

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

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

  809.                 break;

  810.             }

  811. 

  812.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  815. 

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

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

  818.                 break;

  819.             }

  820. 

  821.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

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

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

  824. 

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

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

  827.                 break;

  828.             }

  829. 

  830.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  834. 

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

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

  837.                 break;

  838.             }

  839. 

  840.             case kPluginBridgeNonRtClientSetProgram: {

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

  842. 

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

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

  845.                 break;

  846.             }

  847. 

  848.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  850. 

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

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

  853.                 break;

  854.             }

  855. 

  856.             case kPluginBridgeNonRtClientSetCustomData: {

  857.                 // type

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

  859.                 char typeStr[typeSize+1];

  860.                 carla_zeroChars(typeStr, typeSize+1);

  861.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  862. 

  863.                 // key

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

  865.                 char keyStr[keySize+1];

  866.                 carla_zeroChars(keyStr, keySize+1);

  867.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  868. 

  869.                 // value

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

  871.                 char valueStr[valueSize+1];

  872.                 carla_zeroChars(valueStr, valueSize+1);

  873. 

  874.                 if (valueSize > 0)

  875.                     fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  876. 

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

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

  879.                 break;

  880.             }

  881. 

  882.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  884.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  885. 

  886.                 char chunkFilePathTry[size+1];

  887.                 carla_zeroChars(chunkFilePathTry, size+1);

  888.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  889. 

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

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

  892. 

  893.                 String chunkFilePath(chunkFilePathTry);

  894. 

  895. #ifdef CARLA_OS_WIN

  896.                 // check if running under Wine

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

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

  899. #endif

  900. 

  901.                 File chunkFile(chunkFilePath);

  902.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  903. 

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

  905.                 chunkFile.deleteFile();

  906.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  907. 

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

  909. 

  910. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  912. #else

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

  914. #endif

  915.                 break;

  916.             }

  917. 

  918.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  921. 

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

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

  924.                 break;

  925.             }

  926. 

  927.             case kPluginBridgeNonRtClientSetOption: {

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

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

  930. 

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

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

  933.                 break;

  934.             }

  935. 

  936.             case kPluginBridgeNonRtClientSetOptions: {

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

  938. 

  939.                 if (plugin != nullptr)

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

  941.                 break;

  942.             }

  943. 

  944.             case kPluginBridgeNonRtClientGetParameterText: {

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

  946. 

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

  948.                 {

  949.                     char bufStr[STR_MAX+1];

  950.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  953. 

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

  955. 

  956.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  957. 

  958.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  959. 

  960.                     fShmNonRtServerControl.writeInt(index);

  961.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  962.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  963.                     fShmNonRtServerControl.commitWrite();

  964. 

  965.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  966.                 }

  967. 

  968.                 break;

  969.             }

  970. 

  971.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  973.                     break;

  974. 

  975.                 plugin->prepareForSave();

  976. 

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

  978.                 {

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

  980. 

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

  982.                         continue;

  983. 

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

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

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

  987. 

  988.                     {

  989.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  990. 

  991.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  992. 

  993.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  995. 

  996.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  998. 

  999.                         fShmNonRtServerControl.writeUInt(valueLen);

  1000. 

  1001.                         if (valueLen > 0)

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

  1003. 

  1004.                         fShmNonRtServerControl.commitWrite();

  1005.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1006.                     }

  1007.                 }

  1008. 

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

  1010.                 {

  1011.                     void* data = nullptr;

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

  1013.                     {

  1014.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1015. 

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

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

  1018. 

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

  1020. 

  1021.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1022.                         filePath += fShmAudioPool.getFilenameSuffix();

  1023. 

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

  1025.                         {

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

  1027. 

  1028.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1029. 

  1030.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1031.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1033.                             fShmNonRtServerControl.commitWrite();

  1034.                         }

  1035.                     }

  1036.                 }

  1037. 

  1038.                 {

  1039.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1040. 

  1041.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1042.                     fShmNonRtServerControl.commitWrite();

  1043.                 }

  1044.                 break;

  1045.             }

  1046. 

  1047.             case kPluginBridgeNonRtClientRestoreLV2State:

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

  1049.                     plugin->restoreLV2State();

  1050.                 break;

  1051. 

  1052.             case kPluginBridgeNonRtClientShowUI:

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

  1054.                     plugin->showCustomUI(true);

  1055.                 break;

  1056. 

  1057.             case kPluginBridgeNonRtClientHideUI:

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

  1059.                     plugin->showCustomUI(false);

  1060.                 break;

  1061. 

  1062.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1065. 

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

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

  1068.                 break;

  1069.             }

  1070. 

  1071.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1073. 

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

  1075.                     plugin->uiProgramChange(index);

  1076.                 break;

  1077.             }

  1078. 

  1079.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1081. 

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

  1083.                     plugin->uiMidiProgramChange(index);

  1084.                 break;

  1085.             }

  1086. 

  1087.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1091. 

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

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

  1094.                 break;

  1095.             }

  1096. 

  1097.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1100. 

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

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

  1103.                 break;

  1104.             }

  1105. 

  1106.             case kPluginBridgeNonRtClientQuit:

  1107.                 fClosingDown = true;

  1108.                 signalThreadShouldExit();

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

  1110.                 break;

  1111.             }

  1112.         }

  1113.     }

  1114. 

  1115.     // -------------------------------------------------------------------

  1116. 

  1117. protected:

  1118.     void run() override

  1119.     {

  1120. #ifdef __SSE2_MATH__

  1121.         // Set FTZ and DAZ flags

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

  1123. #endif

  1124. 

  1125.         bool quitReceived = false;

  1126. 

  1127.         for (; ! shouldThreadExit();)

  1128.         {

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

  1130. 

  1131.             if (! helper.ok)

  1132.                 continue;

  1133. 

  1134.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1135.             {

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

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

  1138. 

  1139. #ifdef DEBUG

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

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

  1142.                 }

  1143. #endif

  1144. 

  1145.                 switch (opcode)

  1146.                 {

  1147.                 case kPluginBridgeRtClientNull:

  1148.                     break;

  1149. 

  1150.                 case kPluginBridgeRtClientSetAudioPool: {

  1151.                     if (fShmAudioPool.data != nullptr)

  1152.                     {

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

  1154.                         fShmAudioPool.data = nullptr;

  1155.                     }

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

  1157.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1159.                     break;

  1160.                 }

  1161. 

  1162.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1164.                     pData->bufferSize = bufferSize;

  1165.                     bufferSizeChanged(bufferSize);

  1166.                     break;

  1167.                 }

  1168. 

  1169.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1171.                     pData->sampleRate = sampleRate;

  1172.                     sampleRateChanged(sampleRate);

  1173.                     break;

  1174.                 }

  1175. 

  1176.                 case kPluginBridgeRtClientSetOnline:

  1177.                     fIsOffline = fShmRtClientControl.readBool();

  1178.                     offlineModeChanged(fIsOffline);

  1179.                     break;

  1180. 

  1181.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1186. 

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

  1188.                     {

  1189.                         event->type    = kEngineEventTypeControl;

  1190.                         event->time    = time;

  1191.                         event->channel = channel;

  1192.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1193.                         event->ctrl.param = param;

  1194.                         event->ctrl.value = value;

  1195.                     }

  1196.                     break;

  1197.                 }

  1198. 

  1199.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1203. 

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

  1205.                     {

  1206.                         event->type    = kEngineEventTypeControl;

  1207.                         event->time    = time;

  1208.                         event->channel = channel;

  1209.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1210.                         event->ctrl.param = index;

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

  1212.                     }

  1213.                     break;

  1214.                 }

  1215. 

  1216.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1220. 

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

  1222.                     {

  1223.                         event->type    = kEngineEventTypeControl;

  1224.                         event->time    = time;

  1225.                         event->channel = channel;

  1226.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1227.                         event->ctrl.param = index;

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

  1229.                     }

  1230.                     break;

  1231.                 }

  1232. 

  1233.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1236. 

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

  1238.                     {

  1239.                         event->type    = kEngineEventTypeControl;

  1240.                         event->time    = time;

  1241.                         event->channel = channel;

  1242.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1243.                         event->ctrl.param = 0;

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

  1245.                     }

  1246.                 }   break;

  1247. 

  1248.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1251. 

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

  1253.                     {

  1254.                         event->type    = kEngineEventTypeControl;

  1255.                         event->time    = time;

  1256.                         event->channel = channel;

  1257.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1258.                         event->ctrl.param = 0;

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

  1260.                     }

  1261.                 }   break;

  1262. 

  1263.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1267.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1268. 

  1269.                     // FIXME variable-size stack

  1270.                     uint8_t data[size];

  1271. 

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

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

  1274. 

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

  1276.                     {

  1277.                         event->type    = kEngineEventTypeMidi;

  1278.                         event->time    = time;

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

  1280. 

  1281.                         event->midi.port = port;

  1282.                         event->midi.size = size;

  1283. 

  1284.                         if (size > EngineMidiEvent::kDataSize)

  1285.                         {

  1286.                             event->midi.dataExt = data;

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

  1288.                         }

  1289.                         else

  1290.                         {

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

  1292. 

  1293.                             uint8_t i=1;

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

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

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

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

  1298. 

  1299.                             event->midi.dataExt = nullptr;

  1300.                         }

  1301.                     }

  1302.                     break;

  1303.                 }

  1304. 

  1305.                 case kPluginBridgeRtClientProcess: {

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

  1307. 

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

  1309. 

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

  1311.                     {

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

  1313. 

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

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

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

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

  1318. 

  1319.                         const float* audioIn[audioInCount];

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

  1321.                         const float* cvIn[cvInCount];

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

  1323. 

  1324.                         float* fdata = fShmAudioPool.data;

  1325. 

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

  1327.                             audioIn[i] = fdata;

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

  1329.                             audioOut[i] = fdata;

  1330. 

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

  1332.                             cvIn[i] = fdata;

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

  1334.                             cvOut[i] = fdata;

  1335. 

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

  1337. 

  1338.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1339.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1340.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1342. 

  1343.                         if (timeInfo.bbt.valid)

  1344.                         {

  1345.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1346.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1347.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1348. 

  1349.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1350.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1351. 

  1352.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1353.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1354.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1355.                         }

  1356. 

  1357.                         plugin->initBuffers();

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

  1359.                         plugin->unlock();

  1360.                     }

  1361. 

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

  1363.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1364.                     std::size_t curMidiDataPos = 0;

  1365. 

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

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

  1368. 

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

  1370.                     {

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

  1372.                         {

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

  1374. 

  1375.                             if (event.type == kEngineEventTypeNull)

  1376.                                 break;

  1377. 

  1378.                             if (event.type == kEngineEventTypeControl)

  1379.                             {

  1380.                                 uint8_t data[3];

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

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

  1383. 

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

  1385.                                     break;

  1386. 

  1387.                                 // set time

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

  1389.                                 midiData = midiData + 4;

  1390.                                 curMidiDataPos += 4;

  1391. 

  1392.                                 // set port

  1393.                                 *midiData++ = 0;

  1394.                                 ++curMidiDataPos;

  1395. 

  1396.                                 // set size

  1397.                                 *midiData++ = size;

  1398.                                 ++curMidiDataPos;

  1399. 

  1400.                                 // set data

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

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

  1403. 

  1404.                                 curMidiDataPos += size;

  1405.                             }

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

  1407.                             {

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

  1409. 

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

  1411.                                     break;

  1412. 

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

  1414. 

  1415.                                 // set time

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

  1417.                                 midiData += 4;

  1418.                                 curMidiDataPos += 4;

  1419. 

  1420.                                 // set port

  1421.                                 *midiData++ = _midiEvent.port;

  1422.                                 ++curMidiDataPos;

  1423. 

  1424.                                 // set size

  1425.                                 *midiData++ = _midiEvent.size;

  1426.                                 ++curMidiDataPos;

  1427. 

  1428.                                 // set data

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

  1430. 

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

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

  1433. 

  1434.                                 curMidiDataPos += _midiEvent.size;

  1435.                             }

  1436.                         }

  1437. 

  1438.                         if (curMidiDataPos != 0 &&

  1439.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1440.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1441. 

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

  1443.                     }

  1444. 

  1445.                 }   break;

  1446. 

  1447.                 case kPluginBridgeRtClientQuit: {

  1448.                     quitReceived = true;

  1449.                     fClosingDown = true;

  1450.                     signalThreadShouldExit();

  1451.                 }   break;

  1452.                 }

  1453.             }

  1454.         }

  1455. 

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

  1457. 

  1458.         if (! quitReceived)

  1459.         {

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

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

  1462. 

  1463.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1464.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1465.             fShmNonRtServerControl.writeUInt(messageSize);

  1466.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1467.             fShmNonRtServerControl.commitWrite();

  1468.         }

  1469.     }

  1470. 

  1471.     // called from process thread above

  1472.     EngineEvent* getNextFreeInputEvent() const noexcept

  1473.     {

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

  1475.         {

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

  1477. 

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

  1479.                 return event;

  1480.         }

  1481.         return nullptr;

  1482.     }

  1483. 

  1484.     void latencyChanged(const uint32_t samples) noexcept override

  1485.     {

  1486.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1487. 

  1488.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1489.         fShmNonRtServerControl.writeUInt(samples);

  1490.         fShmNonRtServerControl.commitWrite();

  1491.     }

  1492. 

  1493.     // -------------------------------------------------------------------

  1494. 

  1495. private:

  1496.     BridgeAudioPool          fShmAudioPool;

  1497.     BridgeRtClientControl    fShmRtClientControl;

  1498.     BridgeNonRtClientControl fShmNonRtClientControl;

  1499.     BridgeNonRtServerControl fShmNonRtServerControl;

  1500. 

  1501.     CarlaString fBaseNameAudioPool;

  1502.     CarlaString fBaseNameRtClientControl;

  1503.     CarlaString fBaseNameNonRtClientControl;

  1504.     CarlaString fBaseNameNonRtServerControl;

  1505. 

  1506.     bool fClosingDown;

  1507.     bool fIsOffline;

  1508.     bool fFirstIdle;

  1509.     int64_t fLastPingTime;

  1510. 

  1511.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1512. };

  1513. 

  1514. // -----------------------------------------------------------------------

  1515. 

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

  1517. {

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

  1519. }

  1520. 

  1521. // -----------------------------------------------------------------------

  1522. 

  1523. CARLA_BACKEND_END_NAMESPACE

  1524. 

  1525. // -----------------------------------------------------------------------

  1526. 

  1527. #include "CarlaBridgeUtils.cpp"

  1528. 

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