falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
3982 Commits
17 Branches
341MB
Tree: dd34da6c36
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dd34da6c36'
${ noResults }
Carla/source/backend/engine/CarlaEngineBridge.cpp

1406 lines
57KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #ifndef BUILD_BRIDGE

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

  20. #endif

  21. 

  22. #include "CarlaEngineInternal.hpp"

  23. #include "CarlaPlugin.hpp"

  24. 

  25. #include "CarlaBackendUtils.hpp"

  26. #include "CarlaBase64Utils.hpp"

  27. #include "CarlaBridgeUtils.hpp"

  28. #include "CarlaMIDI.h"

  29. 

  30. #ifdef __SSE2_MATH__

  31. # include <xmmintrin.h>

  32. #endif

  33. 

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

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

  36. 

  37. // must be last

  38. #include "jackbridge/JackBridge.hpp"

  39. 

  40. using water::File;

  41. using water::MemoryBlock;

  42. using water::String;

  43. using water::Time;

  44. 

  45. CARLA_BACKEND_START_NAMESPACE

  46. 

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

  48. // Bridge Engine client

  49. 

  50. struct LatencyChangedCallback {

  51.     virtual ~LatencyChangedCallback() noexcept {}

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

  53. };

  54. 

  55. class CarlaEngineBridgeClient : public CarlaEngineClient

  56. {

  57. public:

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

  59.         : CarlaEngineClient(engine),

  60.           fLatencyCallback(cb) {}

  61. 

  62. protected:

  63.     void setLatency(const uint32_t samples) noexcept override

  64.     {

  65.         if (getLatency() == samples)

  66.             return;

  67. 

  68.         fLatencyCallback->latencyChanged(samples);

  69.         CarlaEngineClient::setLatency(samples);

  70.     }

  71. 

  72. private:

  73.     LatencyChangedCallback* const fLatencyCallback;

  74. 

  75.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  76. };

  77. 

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

  79. 

  80. class CarlaEngineBridge : public CarlaEngine,

  81.                           private CarlaThread,

  82.                           private LatencyChangedCallback

  83. {

  84. public:

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

  86.         : CarlaEngine(),

  87.           CarlaThread("CarlaEngineBridge"),

  88.           fShmAudioPool(),

  89.           fShmRtClientControl(),

  90.           fShmNonRtClientControl(),

  91.           fShmNonRtServerControl(),

  92.           fBaseNameAudioPool(audioPoolBaseName),

  93.           fBaseNameRtClientControl(rtClientBaseName),

  94.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  95.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  96.           fIsOffline(false),

  97.           fFirstIdle(true),

  98.           fLastPingTime(-1)

  99.     {

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

  101.     }

  102. 

  103.     ~CarlaEngineBridge() noexcept override

  104.     {

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

  106. 

  107.         clear();

  108.     }

  109. 

  110.     // -------------------------------------

  111.     // CarlaEngine virtual calls

  112. 

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

  114.     {

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

  116. 

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

  118.         {

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

  120.             return false;

  121.         }

  122. 

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

  124.         {

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

  126.             return false;

  127.         }

  128. 

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

  130.         {

  131.             clear();

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

  133.             return false;

  134.         }

  135. 

  136.         if (! fShmRtClientControl.mapData())

  137.         {

  138.             clear();

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

  140.             return false;

  141.         }

  142. 

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

  144.         {

  145.             clear();

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

  147.             return false;

  148.         }

  149. 

  150.         if (! fShmNonRtClientControl.mapData())

  151.         {

  152.             clear();

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

  154.             return false;

  155.         }

  156. 

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

  158.         {

  159.             clear();

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

  161.             return false;

  162.         }

  163. 

  164.         if (! fShmNonRtServerControl.mapData())

  165.         {

  166.             clear();

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

  168.             return false;

  169.         }

  170. 

  171.         PluginBridgeNonRtClientOpcode opcode;

  172. 

  173.         opcode = fShmNonRtClientControl.readOpcode();

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

  175. 

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

  177.         CARLA_SAFE_ASSERT_RETURN(apiVersion == CARLA_PLUGIN_BRIDGE_API_VERSION, false);

  178. 

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

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

  181. 

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

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

  184. 

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

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

  187. 

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

  189.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  190.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  191.         {

  192.             carla_stderr2("CarlaJackAppClient: data size mismatch");

  193.             return false;

  194.         }

  195. 

  196.         opcode = fShmNonRtClientControl.readOpcode();

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

  198. 

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

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

  201. 

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

  203.         {

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

  205.             return false;

  206.         }

  207. 

  208.         pData->initTime(nullptr);

  209. 

  210.         // tell backend we're live

  211.         {

  212.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  213. 

  214.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  215.             fShmNonRtServerControl.commitWrite();

  216.         }

  217. 

  218.         startThread(true);

  219.         return true;

  220.     }

  221. 

  222.     bool close() override

  223.     {

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

  225.         fLastPingTime = -1;

  226. 

  227.         CarlaEngine::close();

  228. 

  229.         stopThread(5000);

  230.         clear();

  231. 

  232.         return true;

  233.     }

  234. 

  235.     bool isRunning() const noexcept override

  236.     {

  237.         return isThreadRunning() || ! fFirstIdle;

  238.     }

  239. 

  240.     bool isOffline() const noexcept override

  241.     {

  242.         return fIsOffline;

  243.     }

  244. 

  245.     EngineType getType() const noexcept override

  246.     {

  247.         return kEngineTypeBridge;

  248.     }

  249. 

  250.     const char* getCurrentDriverName() const noexcept override

  251.     {

  252.         return "Bridge";

  253.     }

  254. 

  255.     CarlaEngineClient* addClient(CarlaPlugin* const) override

  256.     {

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

  258.     }

  259. 

  260.     void idle() noexcept override

  261.     {

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

  263.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  264. 

  265.         const bool wasFirstIdle(fFirstIdle);

  266. 

  267.         if (wasFirstIdle)

  268.         {

  269.             fFirstIdle = false;

  270.             fLastPingTime = Time::currentTimeMillis();

  271.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  272. 

  273.             char bufStr[STR_MAX+1];

  274.             uint32_t bufStrSize;

  275. 

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

  277.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  278. 

  279.             // kPluginBridgeNonRtServerPluginInfo1

  280.             {

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

  282.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  288.                 fShmNonRtServerControl.commitWrite();

  289.             }

  290. 

  291.             // kPluginBridgeNonRtServerPluginInfo2

  292.             {

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

  294.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  295. 

  296.                 carla_zeroChars(bufStr, STR_MAX);

  297.                 plugin->getRealName(bufStr);

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

  299.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  300.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  301. 

  302.                 carla_zeroChars(bufStr, STR_MAX);

  303.                 plugin->getLabel(bufStr);

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

  305.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  306.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  307. 

  308.                 carla_zeroChars(bufStr, STR_MAX);

  309.                 plugin->getMaker(bufStr);

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

  311.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  312.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  313. 

  314.                 carla_zeroChars(bufStr, STR_MAX);

  315.                 plugin->getCopyright(bufStr);

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

  317.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  318.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  319. 

  320.                 fShmNonRtServerControl.commitWrite();

  321.             }

  322. 

  323.             // kPluginBridgeNonRtServerAudioCount

  324.             {

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

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

  327. 

  328.                 // uint/ins, uint/outs

  329.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  330.                 fShmNonRtServerControl.writeUInt(aIns);

  331.                 fShmNonRtServerControl.writeUInt(aOuts);

  332.                 fShmNonRtServerControl.commitWrite();

  333. 

  334.                 // kPluginBridgeNonRtServerPortName

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

  336.                 {

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

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

  339. 

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

  341.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  342.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  343.                     fShmNonRtServerControl.writeUInt(i);

  344. 

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

  346.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  347.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  348.                 }

  349. 

  350.                 // kPluginBridgeNonRtServerPortName

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

  352.                 {

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

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

  355. 

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

  357.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  358.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  359.                     fShmNonRtServerControl.writeUInt(i);

  360. 

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

  362.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  363.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  364.                 }

  365.             }

  366. 

  367.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  368. 

  369.             // kPluginBridgeNonRtServerMidiCount

  370.             {

  371.                 // uint/ins, uint/outs

  372.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  375.                 fShmNonRtServerControl.commitWrite();

  376.             }

  377. 

  378.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  379. 

  380.             // kPluginBridgeNonRtServerCvCount

  381.             {

  382.                 // uint/ins, uint/outs

  383.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  386.                 fShmNonRtServerControl.commitWrite();

  387.             }

  388. 

  389.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  390. 

  391.             // kPluginBridgeNonRtServerParameter*

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

  393.             {

  394.                 // uint/count

  395.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  396.                 fShmNonRtServerControl.writeUInt(count);

  397.                 fShmNonRtServerControl.commitWrite();

  398. 

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

  400.                 {

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

  402. 

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

  404.                         continue;

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

  406.                         continue;

  407. 

  408.                     // kPluginBridgeNonRtServerParameterData1

  409.                     {

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

  411.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  412.                         fShmNonRtServerControl.writeUInt(i);

  413.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  414.                         fShmNonRtServerControl.writeUInt(paramData.type);

  415.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  416.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  417.                         fShmNonRtServerControl.commitWrite();

  418.                     }

  419. 

  420.                     // kPluginBridgeNonRtServerParameterData2

  421.                     {

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

  423.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  424.                         fShmNonRtServerControl.writeUInt(i);

  425. 

  426.                         carla_zeroChars(bufStr, STR_MAX);

  427.                         plugin->getParameterName(i, bufStr);

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

  429.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  430.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  431. 

  432.                         carla_zeroChars(bufStr, STR_MAX);

  433.                         plugin->getParameterSymbol(i, bufStr);

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

  435.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  436.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  437. 

  438.                         carla_zeroChars(bufStr, STR_MAX);

  439.                         plugin->getParameterUnit(i, bufStr);

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

  441.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  442.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  443. 

  444.                         fShmNonRtServerControl.commitWrite();

  445.                     }

  446. 

  447.                     // kPluginBridgeNonRtServerParameterRanges

  448.                     {

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

  450. 

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

  452.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  453.                         fShmNonRtServerControl.writeUInt(i);

  454.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  455.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  456.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  457.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  458.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  459.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  460.                         fShmNonRtServerControl.commitWrite();

  461.                     }

  462. 

  463.                     // kPluginBridgeNonRtServerParameterValue2

  464.                     {

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

  466.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  467.                         fShmNonRtServerControl.writeUInt(i);

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

  469.                         fShmNonRtServerControl.commitWrite();

  470.                     }

  471. 

  472.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  473.                 }

  474.             }

  475. 

  476.             // kPluginBridgeNonRtServerProgram*

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

  478.             {

  479.                 // uint/count

  480.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  481.                 fShmNonRtServerControl.writeUInt(count);

  482.                 fShmNonRtServerControl.commitWrite();

  483. 

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

  485.                 {

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

  487.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  488.                     fShmNonRtServerControl.writeUInt(i);

  489. 

  490.                     carla_zeroChars(bufStr, STR_MAX);

  491.                     plugin->getProgramName(i, bufStr);

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

  493.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  494.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  495. 

  496.                     fShmNonRtServerControl.commitWrite();

  497.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  498.                 }

  499.             }

  500. 

  501.             // kPluginBridgeNonRtServerMidiProgram*

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

  503.             {

  504.                 // uint/count

  505.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  506.                 fShmNonRtServerControl.writeUInt(count);

  507.                 fShmNonRtServerControl.commitWrite();

  508. 

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

  510.                 {

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

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

  513. 

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

  515.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  516.                     fShmNonRtServerControl.writeUInt(i);

  517.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  518.                     fShmNonRtServerControl.writeUInt(mpData.program);

  519. 

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

  521.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  523. 

  524.                     fShmNonRtServerControl.commitWrite();

  525.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  526.                 }

  527.             }

  528. 

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

  530.             {

  531.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  532.                 fShmNonRtServerControl.writeUInt(latency);

  533.                 fShmNonRtServerControl.commitWrite();

  534.             }

  535. 

  536.             // ready!

  537.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  538.             fShmNonRtServerControl.commitWrite();

  539.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  540. 

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

  542.             fLastPingTime = Time::currentTimeMillis();

  543.         }

  544. 

  545.         // send parameter outputs

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

  547.         {

  548.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  549. 

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

  551.             {

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

  553.                     continue;

  554. 

  555.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  556.                 fShmNonRtServerControl.writeUInt(i);

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

  558. 

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

  560.                 if (! fShmNonRtServerControl.commitWrite())

  561.                     break;

  562.             }

  563.         }

  564. 

  565.         CarlaEngine::idle();

  566. 

  567.         try {

  568.             handleNonRtData();

  569.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  570. 

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

  572.         {

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

  574.             signalThreadShouldExit();

  575.             callback(ENGINE_CALLBACK_QUIT, 0, 0, 0, 0.0f, nullptr);

  576.         }

  577.     }

  578. 

  579.     void callback(const EngineCallbackOpcode action, const uint pluginId, const int value1, const int value2, const float value3, const char* const valueStr) noexcept override

  580.     {

  581.         CarlaEngine::callback(action, pluginId, value1, value2, value3, valueStr);

  582. 

  583.         if (fLastPingTime < 0)

  584.             return;

  585. 

  586.         switch (action)

  587.         {

  588.         // uint/index float/value

  589.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  590.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  591.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  592.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  594.             fShmNonRtServerControl.writeFloat(value3);

  595.             fShmNonRtServerControl.commitWrite();

  596.         }   break;

  597. 

  598.         // uint/index float/value

  599.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  600.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  601.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  602.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  604.             fShmNonRtServerControl.writeFloat(value3);

  605.             fShmNonRtServerControl.commitWrite();

  606.         }   break;

  607. 

  608.         // int/index

  609.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  610.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  611.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  612.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  613.             fShmNonRtServerControl.writeInt(value1);

  614.             fShmNonRtServerControl.commitWrite();

  615.         }   break;

  616. 

  617.         // int/index

  618.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  619.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  620.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  621.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  622.             fShmNonRtServerControl.writeInt(value1);

  623.             fShmNonRtServerControl.commitWrite();

  624.         }   break;

  625. 

  626.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  627.             if (value1 != 1)

  628.             {

  629.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  630.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  631.                 fShmNonRtServerControl.commitWrite();

  632.             }

  633.             break;

  634. 

  635.         default:

  636.             break;

  637.         }

  638.     }

  639. 

  640.     // -------------------------------------------------------------------

  641. 

  642.     void clear() noexcept

  643.     {

  644.         fShmAudioPool.clear();

  645.         fShmRtClientControl.clear();

  646.         fShmNonRtClientControl.clear();

  647.         fShmNonRtServerControl.clear();

  648.     }

  649. 

  650.     void handleNonRtData()

  651.     {

  652.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  653.         {

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

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

  656. 

  657. #ifdef DEBUG

  658.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  660.             }

  661. #endif

  662. 

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

  664.                 fLastPingTime = Time::currentTimeMillis();

  665. 

  666.             switch (opcode)

  667.             {

  668.             case kPluginBridgeNonRtClientNull:

  669.                 break;

  670. 

  671.             case kPluginBridgeNonRtClientVersion: {

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

  673.                 CARLA_SAFE_ASSERT_UINT2(apiVersion == CARLA_PLUGIN_BRIDGE_API_VERSION, apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION);

  674.             }   break;

  675. 

  676.             case kPluginBridgeNonRtClientPing: {

  677.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  678. 

  679.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  680.                 fShmNonRtServerControl.commitWrite();

  681.             }   break;

  682. 

  683.             case kPluginBridgeNonRtClientPingOnOff: {

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

  685. 

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

  687.             }   break;

  688. 

  689.             case kPluginBridgeNonRtClientActivate:

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

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

  692.                 break;

  693. 

  694.             case kPluginBridgeNonRtClientDeactivate:

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

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

  697.                 break;

  698. 

  699.             case kPluginBridgeNonRtClientInitialSetup:

  700.                 // should never happen!!

  701.                 fShmNonRtServerControl.readUInt();

  702.                 fShmNonRtServerControl.readDouble();

  703.                 break;

  704. 

  705.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  708. 

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

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

  711.                 break;

  712.             }

  713. 

  714.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  717. 

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

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

  720.                 break;

  721.             }

  722. 

  723.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  726. 

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

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

  729.                 break;

  730.             }

  731. 

  732.             case kPluginBridgeNonRtClientSetProgram: {

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

  734. 

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

  736.                     plugin->setProgram(index, false, false, false);

  737.                 break;

  738.             }

  739. 

  740.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  742. 

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

  744.                     plugin->setMidiProgram(index, false, false, false);

  745.                 break;

  746.             }

  747. 

  748.             case kPluginBridgeNonRtClientSetCustomData: {

  749.                 // type

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

  751.                 char typeStr[typeSize+1];

  752.                 carla_zeroChars(typeStr, typeSize+1);

  753.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  754. 

  755.                 // key

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

  757.                 char keyStr[keySize+1];

  758.                 carla_zeroChars(keyStr, keySize+1);

  759.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  760. 

  761.                 // value

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

  763.                 char valueStr[valueSize+1];

  764.                 carla_zeroChars(valueStr, valueSize+1);

  765.                 fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  766. 

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

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

  769.                 break;

  770.             }

  771. 

  772.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  774.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  775. 

  776.                 char chunkFilePathTry[size+1];

  777.                 carla_zeroChars(chunkFilePathTry, size+1);

  778.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  779. 

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

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

  782. 

  783.                 String chunkFilePath(chunkFilePathTry);

  784. 

  785. #ifdef CARLA_OS_WIN

  786.                 // check if running under Wine

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

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

  789. #endif

  790. 

  791.                 File chunkFile(chunkFilePath);

  792.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  793. 

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

  795.                 chunkFile.deleteFile();

  796.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  797. 

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

  799. 

  800. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  802. #else

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

  804. #endif

  805.                 break;

  806.             }

  807. 

  808.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  811. 

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

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

  814.                 break;

  815.             }

  816. 

  817.             case kPluginBridgeNonRtClientSetOption: {

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

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

  820. 

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

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

  823.                 break;

  824.             }

  825. 

  826.             case kPluginBridgeNonRtClientGetParameterText: {

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

  828. 

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

  830.                 {

  831.                     char strBuf[STR_MAX];

  832.                     plugin->getParameterText(index, strBuf);

  833.                     const uint32_t strBufLen(std::strlen(strBuf));

  834. 

  835.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  836. 

  837.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  838. 

  839.                     fShmNonRtServerControl.writeInt(index);

  840.                     fShmNonRtServerControl.writeUInt(strBufLen);

  841.                     fShmNonRtServerControl.writeCustomData(strBuf, strBufLen);

  842.                     fShmNonRtServerControl.commitWrite();

  843. 

  844.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  845.                 }

  846. 

  847.                 break;

  848.             }

  849. 

  850.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  852. 

  853.                 plugin->prepareForSave();

  854. 

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

  856.                 {

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

  858. 

  859.                     if (std::strcmp(cdata.type, CUSTOM_DATA_TYPE_STRING) == 0 && std::strcmp(cdata.key, "CarlaLoadLv2StateNow") == 0 && std::strcmp(cdata.value, "true") == 0)

  860.                         continue;

  861. 

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

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

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

  865. 

  866.                     {

  867.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  868. 

  869.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  870. 

  871.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  873. 

  874.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  876. 

  877.                         fShmNonRtServerControl.writeUInt(valueLen);

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

  879. 

  880.                         fShmNonRtServerControl.commitWrite();

  881.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  882.                     }

  883.                 }

  884. 

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

  886.                 {

  887.                     void* data = nullptr;

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

  889.                     {

  890.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  891. 

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

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

  894. 

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

  896. 

  897.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  898.                         filePath += fShmAudioPool.getFilenameSuffix();

  899. 

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

  901.                         {

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

  903. 

  904.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  905. 

  906.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  907.                             fShmNonRtServerControl.writeUInt(ulength);

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

  909.                             fShmNonRtServerControl.commitWrite();

  910.                         }

  911.                     }

  912.                 }

  913. 

  914.                 {

  915.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  916. 

  917.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  918.                     fShmNonRtServerControl.commitWrite();

  919.                 }

  920.                 break;

  921.             }

  922. 

  923.             case kPluginBridgeNonRtClientShowUI:

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

  925.                     plugin->showCustomUI(true);

  926.                 break;

  927. 

  928.             case kPluginBridgeNonRtClientHideUI:

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

  930.                     plugin->showCustomUI(false);

  931.                 break;

  932. 

  933.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  936. 

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

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

  939.                 break;

  940.             }

  941. 

  942.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  944. 

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

  946.                     plugin->uiProgramChange(index);

  947.                 break;

  948.             }

  949. 

  950.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  952. 

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

  954.                     plugin->uiMidiProgramChange(index);

  955.                 break;

  956.             }

  957. 

  958.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  962. 

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

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

  965.                 break;

  966.             }

  967. 

  968.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  971. 

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

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

  974.                 break;

  975.             }

  976. 

  977.             case kPluginBridgeNonRtClientQuit:

  978.                 signalThreadShouldExit();

  979.                 callback(ENGINE_CALLBACK_QUIT, 0, 0, 0, 0.0f, nullptr);

  980.                 break;

  981.             }

  982.         }

  983.     }

  984. 

  985.     // -------------------------------------------------------------------

  986. 

  987. protected:

  988.     void run() override

  989.     {

  990. #ifdef __SSE2_MATH__

  991.         // Set FTZ and DAZ flags

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

  993. #endif

  994. 

  995.         bool quitReceived = false;

  996. 

  997.         for (; ! shouldThreadExit();)

  998.         {

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

  1000. 

  1001.             if (! helper.ok)

  1002.                 continue;

  1003. 

  1004.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1005.             {

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

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

  1008. 

  1009. #ifdef DEBUG

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

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

  1012.                 }

  1013. #endif

  1014. 

  1015.                 switch (opcode)

  1016.                 {

  1017.                 case kPluginBridgeRtClientNull:

  1018.                     break;

  1019. 

  1020.                 case kPluginBridgeRtClientSetAudioPool: {

  1021.                     if (fShmAudioPool.data != nullptr)

  1022.                     {

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

  1024.                         fShmAudioPool.data = nullptr;

  1025.                     }

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

  1027.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1029.                     break;

  1030.                 }

  1031. 

  1032.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1034.                     pData->bufferSize = bufferSize;

  1035.                     bufferSizeChanged(bufferSize);

  1036.                     break;

  1037.                 }

  1038. 

  1039.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1041.                     pData->sampleRate = sampleRate;

  1042.                     sampleRateChanged(sampleRate);

  1043.                     break;

  1044.                 }

  1045. 

  1046.                 case kPluginBridgeRtClientSetOnline:

  1047.                     fIsOffline = fShmRtClientControl.readBool();

  1048.                     offlineModeChanged(fIsOffline);

  1049.                     break;

  1050. 

  1051.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1056. 

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

  1058.                     {

  1059.                         event->type    = kEngineEventTypeControl;

  1060.                         event->time    = time;

  1061.                         event->channel = channel;

  1062.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1063.                         event->ctrl.param = param;

  1064.                         event->ctrl.value = value;

  1065.                     }

  1066.                     break;

  1067.                 }

  1068. 

  1069.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1073. 

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

  1075.                     {

  1076.                         event->type    = kEngineEventTypeControl;

  1077.                         event->time    = time;

  1078.                         event->channel = channel;

  1079.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1080.                         event->ctrl.param = index;

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

  1082.                     }

  1083.                     break;

  1084.                 }

  1085. 

  1086.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1090. 

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

  1092.                     {

  1093.                         event->type    = kEngineEventTypeControl;

  1094.                         event->time    = time;

  1095.                         event->channel = channel;

  1096.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1097.                         event->ctrl.param = index;

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

  1099.                     }

  1100.                     break;

  1101.                 }

  1102. 

  1103.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1106. 

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

  1108.                     {

  1109.                         event->type    = kEngineEventTypeControl;

  1110.                         event->time    = time;

  1111.                         event->channel = channel;

  1112.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1113.                         event->ctrl.param = 0;

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

  1115.                     }

  1116.                 }   break;

  1117. 

  1118.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1121. 

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

  1123.                     {

  1124.                         event->type    = kEngineEventTypeControl;

  1125.                         event->time    = time;

  1126.                         event->channel = channel;

  1127.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1128.                         event->ctrl.param = 0;

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

  1130.                     }

  1131.                 }   break;

  1132. 

  1133.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1137.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1138. 

  1139.                     // FIXME variable-size stack

  1140.                     uint8_t data[size];

  1141. 

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

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

  1144. 

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

  1146.                     {

  1147.                         event->type    = kEngineEventTypeMidi;

  1148.                         event->time    = time;

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

  1150. 

  1151.                         event->midi.port = port;

  1152.                         event->midi.size = size;

  1153. 

  1154.                         if (size > EngineMidiEvent::kDataSize)

  1155.                         {

  1156.                             event->midi.dataExt = data;

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

  1158.                         }

  1159.                         else

  1160.                         {

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

  1162. 

  1163.                             uint8_t i=1;

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

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

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

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

  1168. 

  1169.                             event->midi.dataExt = nullptr;

  1170.                         }

  1171.                     }

  1172.                     break;

  1173.                 }

  1174. 

  1175.                 case kPluginBridgeRtClientProcess: {

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

  1177. 

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

  1179.                     {

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

  1181. 

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

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

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

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

  1186. 

  1187.                         const float* audioIn[audioInCount];

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

  1189.                         const float* cvIn[cvInCount];

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

  1191. 

  1192.                         float* fdata = fShmAudioPool.data;

  1193. 

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

  1195.                             audioIn[i] = fdata;

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

  1197.                             audioOut[i] = fdata;

  1198. 

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

  1200.                             cvIn[i] = fdata;

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

  1202.                             cvOut[i] = fdata;

  1203. 

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

  1205. 

  1206.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1207.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1208.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1210. 

  1211.                         if (timeInfo.bbt.valid)

  1212.                         {

  1213.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1214.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1215.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1216. 

  1217.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1218.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1219. 

  1220.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1221.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1222.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1223.                         }

  1224. 

  1225.                         plugin->initBuffers();

  1226.                         plugin->process(audioIn, audioOut, cvIn, cvOut, pData->bufferSize);

  1227.                         plugin->unlock();

  1228.                     }

  1229. 

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

  1231.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1232.                     std::size_t curMidiDataPos = 0;

  1233. 

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

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

  1236. 

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

  1238.                     {

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

  1240.                         {

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

  1242. 

  1243.                             if (event.type == kEngineEventTypeNull)

  1244.                                 break;

  1245. 

  1246.                             if (event.type == kEngineEventTypeControl)

  1247.                             {

  1248.                                 uint8_t size;

  1249.                                 uint8_t data[3];

  1250.                                 event.ctrl.convertToMidiData(event.channel, size, data);

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

  1252. 

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

  1254.                                     break;

  1255. 

  1256.                                 // set time

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

  1258.                                 midiData = midiData + 4;

  1259. 

  1260.                                 // set port

  1261.                                 *midiData++ = 0;

  1262. 

  1263.                                 // set size

  1264.                                 *midiData++ = size;

  1265. 

  1266.                                 // set data

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

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

  1269. 

  1270.                                 curMidiDataPos += kBridgeBaseMidiOutHeaderSize + size;

  1271.                             }

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

  1273.                             {

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

  1275. 

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

  1277.                                     break;

  1278. 

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

  1280. 

  1281.                                 // set time

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

  1283.                                 midiData += 4;

  1284. 

  1285.                                 // set port

  1286.                                 *midiData++ = _midiEvent.port;

  1287. 

  1288.                                 // set size

  1289.                                 *midiData++ = _midiEvent.size;

  1290. 

  1291.                                 // set data

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

  1293. 

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

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

  1296. 

  1297.                                 curMidiDataPos += kBridgeBaseMidiOutHeaderSize + _midiEvent.size;

  1298.                             }

  1299.                         }

  1300. 

  1301.                         if (curMidiDataPos != 0 &&

  1302.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1303.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1304. 

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

  1306.                     }

  1307. 

  1308.                 }   break;

  1309. 

  1310.                 case kPluginBridgeRtClientQuit: {

  1311.                     quitReceived = true;

  1312.                     signalThreadShouldExit();

  1313.                 }   break;

  1314.                 }

  1315.             }

  1316.         }

  1317. 

  1318.         callback(ENGINE_CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0.0f, nullptr);

  1319. 

  1320.         if (! quitReceived)

  1321.         {

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

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

  1324. 

  1325.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1326.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1327.             fShmNonRtServerControl.writeUInt(messageSize);

  1328.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1329.             fShmNonRtServerControl.commitWrite();

  1330.         }

  1331.     }

  1332. 

  1333.     // called from process thread above

  1334.     EngineEvent* getNextFreeInputEvent() const noexcept

  1335.     {

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

  1337.         {

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

  1339. 

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

  1341.                 return event;

  1342.         }

  1343.         return nullptr;

  1344.     }

  1345. 

  1346.     void latencyChanged(const uint32_t samples) noexcept override

  1347.     {

  1348.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1349. 

  1350.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1351.         fShmNonRtServerControl.writeUInt(samples);

  1352.         fShmNonRtServerControl.commitWrite();

  1353.     }

  1354. 

  1355.     // -------------------------------------------------------------------

  1356. 

  1357. private:

  1358.     BridgeAudioPool          fShmAudioPool;

  1359.     BridgeRtClientControl    fShmRtClientControl;

  1360.     BridgeNonRtClientControl fShmNonRtClientControl;

  1361.     BridgeNonRtServerControl fShmNonRtServerControl;

  1362. 

  1363.     CarlaString fBaseNameAudioPool;

  1364.     CarlaString fBaseNameRtClientControl;

  1365.     CarlaString fBaseNameNonRtClientControl;

  1366.     CarlaString fBaseNameNonRtServerControl;

  1367. 

  1368.     bool fIsOffline;

  1369.     bool fFirstIdle;

  1370.     int64_t fLastPingTime;

  1371. 

  1372.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1373. };

  1374. 

  1375. // -----------------------------------------------------------------------

  1376. 

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

  1378. {

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

  1380. }

  1381. 

  1382. // -----------------------------------------------------------------------

  1383. 

  1384. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1385. CarlaPlugin* CarlaPlugin::newNative(const CarlaPlugin::Initializer&)              { return nullptr; }

  1386. CarlaPlugin* CarlaPlugin::newFileGIG(const CarlaPlugin::Initializer&, const bool) { return nullptr; }

  1387. CarlaPlugin* CarlaPlugin::newFileSF2(const CarlaPlugin::Initializer&, const bool) { return nullptr; }

  1388. CarlaPlugin* CarlaPlugin::newFileSFZ(const CarlaPlugin::Initializer&)             { return nullptr; }

  1389. #endif

  1390. 

  1391. CARLA_BACKEND_END_NAMESPACE

  1392. 

  1393. // -----------------------------------------------------------------------

  1394. 

  1395. #if defined(CARLA_OS_WIN) && ! defined(__WINE__)

  1396. extern "C" __declspec (dllexport)

  1397. #else

  1398. extern "C" __attribute__ ((visibility("default")))

  1399. #endif

  1400. void carla_register_native_plugin_carla();

  1401. void carla_register_native_plugin_carla(){}

  1402. 

  1403. #include "CarlaBridgeUtils.cpp"

  1404. 

  1405. // -----------------------------------------------------------------------