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

1417 lines
57KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2018 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.         CarlaPlugin* const plugin(pData->plugins[0].plugin);

  653.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  654. 

  655.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  656.         {

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

  658. 

  659. #ifdef DEBUG

  660.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  662.             }

  663. #endif

  664. 

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

  666.                 fLastPingTime = Time::currentTimeMillis();

  667. 

  668.             switch (opcode)

  669.             {

  670.             case kPluginBridgeNonRtClientNull:

  671.                 break;

  672. 

  673.             case kPluginBridgeNonRtClientVersion: {

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

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

  676.             }   break;

  677. 

  678.             case kPluginBridgeNonRtClientPing: {

  679.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  680. 

  681.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  682.                 fShmNonRtServerControl.commitWrite();

  683.             }   break;

  684. 

  685.             case kPluginBridgeNonRtClientPingOnOff: {

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

  687. 

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

  689.             }   break;

  690. 

  691.             case kPluginBridgeNonRtClientActivate:

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

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

  694.                 break;

  695. 

  696.             case kPluginBridgeNonRtClientDeactivate:

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

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

  699.                 break;

  700. 

  701.             case kPluginBridgeNonRtClientInitialSetup:

  702.                 // should never happen!!

  703.                 fShmNonRtServerControl.readUInt();

  704.                 fShmNonRtServerControl.readDouble();

  705.                 break;

  706. 

  707.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  710. 

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

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

  713.                 break;

  714.             }

  715. 

  716.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  719. 

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

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

  722.                 break;

  723.             }

  724. 

  725.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  728. 

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

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

  731.                 break;

  732.             }

  733. 

  734.             case kPluginBridgeNonRtClientSetProgram: {

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

  736. 

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

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

  739.                 break;

  740.             }

  741. 

  742.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  744. 

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

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

  747.                 break;

  748.             }

  749. 

  750.             case kPluginBridgeNonRtClientSetCustomData: {

  751.                 // type

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

  753.                 char typeStr[typeSize+1];

  754.                 carla_zeroChars(typeStr, typeSize+1);

  755.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  756. 

  757.                 // key

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

  759.                 char keyStr[keySize+1];

  760.                 carla_zeroChars(keyStr, keySize+1);

  761.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  762. 

  763.                 // value

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

  765.                 char valueStr[valueSize+1];

  766.                 carla_zeroChars(valueStr, valueSize+1);

  767. 

  768.                 if (valueSize > 0)

  769.                     fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  770. 

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

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

  773.                 break;

  774.             }

  775. 

  776.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  778.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  779. 

  780.                 char chunkFilePathTry[size+1];

  781.                 carla_zeroChars(chunkFilePathTry, size+1);

  782.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  783. 

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

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

  786. 

  787.                 String chunkFilePath(chunkFilePathTry);

  788. 

  789. #ifdef CARLA_OS_WIN

  790.                 // check if running under Wine

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

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

  793. #endif

  794. 

  795.                 File chunkFile(chunkFilePath);

  796.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  797. 

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

  799.                 chunkFile.deleteFile();

  800.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  801. 

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

  803. 

  804. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  806. #else

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

  808. #endif

  809.                 break;

  810.             }

  811. 

  812.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  815. 

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

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

  818.                 break;

  819.             }

  820. 

  821.             case kPluginBridgeNonRtClientSetOption: {

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

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

  824. 

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

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

  827.                 break;

  828.             }

  829. 

  830.             case kPluginBridgeNonRtClientGetParameterText: {

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

  832. 

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

  834.                 {

  835.                     char strBuf[STR_MAX];

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

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

  838. 

  839.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  840. 

  841.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  842. 

  843.                     fShmNonRtServerControl.writeInt(index);

  844.                     fShmNonRtServerControl.writeUInt(strBufLen);

  845.                     fShmNonRtServerControl.writeCustomData(strBuf, strBufLen);

  846.                     fShmNonRtServerControl.commitWrite();

  847. 

  848.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  849.                 }

  850. 

  851.                 break;

  852.             }

  853. 

  854.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  856. 

  857.                 plugin->prepareForSave();

  858. 

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

  860.                 {

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

  862. 

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

  864.                         continue;

  865. 

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

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

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

  869. 

  870.                     {

  871.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  872. 

  873.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  874. 

  875.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  877. 

  878.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  880. 

  881.                         fShmNonRtServerControl.writeUInt(valueLen);

  882. 

  883.                         if (valueLen > 0)

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

  885. 

  886.                         fShmNonRtServerControl.commitWrite();

  887.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  888.                     }

  889.                 }

  890. 

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

  892.                 {

  893.                     void* data = nullptr;

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

  895.                     {

  896.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  897. 

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

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

  900. 

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

  902. 

  903.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  904.                         filePath += fShmAudioPool.getFilenameSuffix();

  905. 

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

  907.                         {

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

  909. 

  910.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  911. 

  912.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  913.                             fShmNonRtServerControl.writeUInt(ulength);

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

  915.                             fShmNonRtServerControl.commitWrite();

  916.                         }

  917.                     }

  918.                 }

  919. 

  920.                 {

  921.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  922. 

  923.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  924.                     fShmNonRtServerControl.commitWrite();

  925.                 }

  926.                 break;

  927.             }

  928. 

  929.             case kPluginBridgeNonRtClientShowUI:

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

  931.                     plugin->showCustomUI(true);

  932.                 break;

  933. 

  934.             case kPluginBridgeNonRtClientHideUI:

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

  936.                     plugin->showCustomUI(false);

  937.                 break;

  938. 

  939.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  942. 

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

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

  945.                 break;

  946.             }

  947. 

  948.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  950. 

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

  952.                     plugin->uiProgramChange(index);

  953.                 break;

  954.             }

  955. 

  956.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  958. 

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

  960.                     plugin->uiMidiProgramChange(index);

  961.                 break;

  962.             }

  963. 

  964.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  968. 

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

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

  971.                 break;

  972.             }

  973. 

  974.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  977. 

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

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

  980.                 break;

  981.             }

  982. 

  983.             case kPluginBridgeNonRtClientQuit:

  984.                 signalThreadShouldExit();

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

  986.                 break;

  987.             }

  988.         }

  989.     }

  990. 

  991.     // -------------------------------------------------------------------

  992. 

  993. protected:

  994.     void run() override

  995.     {

  996. #ifdef __SSE2_MATH__

  997.         // Set FTZ and DAZ flags

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

  999. #endif

  1000. 

  1001.         bool quitReceived = false;

  1002. 

  1003.         for (; ! shouldThreadExit();)

  1004.         {

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

  1006. 

  1007.             if (! helper.ok)

  1008.                 continue;

  1009. 

  1010.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1011.             {

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

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

  1014. 

  1015. #ifdef DEBUG

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

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

  1018.                 }

  1019. #endif

  1020. 

  1021.                 switch (opcode)

  1022.                 {

  1023.                 case kPluginBridgeRtClientNull:

  1024.                     break;

  1025. 

  1026.                 case kPluginBridgeRtClientSetAudioPool: {

  1027.                     if (fShmAudioPool.data != nullptr)

  1028.                     {

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

  1030.                         fShmAudioPool.data = nullptr;

  1031.                     }

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

  1033.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1035.                     break;

  1036.                 }

  1037. 

  1038.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1040.                     pData->bufferSize = bufferSize;

  1041.                     bufferSizeChanged(bufferSize);

  1042.                     break;

  1043.                 }

  1044. 

  1045.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1047.                     pData->sampleRate = sampleRate;

  1048.                     sampleRateChanged(sampleRate);

  1049.                     break;

  1050.                 }

  1051. 

  1052.                 case kPluginBridgeRtClientSetOnline:

  1053.                     fIsOffline = fShmRtClientControl.readBool();

  1054.                     offlineModeChanged(fIsOffline);

  1055.                     break;

  1056. 

  1057.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1062. 

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

  1064.                     {

  1065.                         event->type    = kEngineEventTypeControl;

  1066.                         event->time    = time;

  1067.                         event->channel = channel;

  1068.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1069.                         event->ctrl.param = param;

  1070.                         event->ctrl.value = value;

  1071.                     }

  1072.                     break;

  1073.                 }

  1074. 

  1075.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1079. 

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

  1081.                     {

  1082.                         event->type    = kEngineEventTypeControl;

  1083.                         event->time    = time;

  1084.                         event->channel = channel;

  1085.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1086.                         event->ctrl.param = index;

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

  1088.                     }

  1089.                     break;

  1090.                 }

  1091. 

  1092.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1096. 

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

  1098.                     {

  1099.                         event->type    = kEngineEventTypeControl;

  1100.                         event->time    = time;

  1101.                         event->channel = channel;

  1102.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1103.                         event->ctrl.param = index;

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

  1105.                     }

  1106.                     break;

  1107.                 }

  1108. 

  1109.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1112. 

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

  1114.                     {

  1115.                         event->type    = kEngineEventTypeControl;

  1116.                         event->time    = time;

  1117.                         event->channel = channel;

  1118.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1119.                         event->ctrl.param = 0;

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

  1121.                     }

  1122.                 }   break;

  1123. 

  1124.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1127. 

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

  1129.                     {

  1130.                         event->type    = kEngineEventTypeControl;

  1131.                         event->time    = time;

  1132.                         event->channel = channel;

  1133.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1134.                         event->ctrl.param = 0;

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

  1136.                     }

  1137.                 }   break;

  1138. 

  1139.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1143.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1144. 

  1145.                     // FIXME variable-size stack

  1146.                     uint8_t data[size];

  1147. 

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

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

  1150. 

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

  1152.                     {

  1153.                         event->type    = kEngineEventTypeMidi;

  1154.                         event->time    = time;

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

  1156. 

  1157.                         event->midi.port = port;

  1158.                         event->midi.size = size;

  1159. 

  1160.                         if (size > EngineMidiEvent::kDataSize)

  1161.                         {

  1162.                             event->midi.dataExt = data;

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

  1164.                         }

  1165.                         else

  1166.                         {

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

  1168. 

  1169.                             uint8_t i=1;

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

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

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

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

  1174. 

  1175.                             event->midi.dataExt = nullptr;

  1176.                         }

  1177.                     }

  1178.                     break;

  1179.                 }

  1180. 

  1181.                 case kPluginBridgeRtClientProcess: {

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

  1183. 

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

  1185.                     {

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

  1187. 

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

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

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

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

  1192. 

  1193.                         const float* audioIn[audioInCount];

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

  1195.                         const float* cvIn[cvInCount];

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

  1197. 

  1198.                         float* fdata = fShmAudioPool.data;

  1199. 

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

  1201.                             audioIn[i] = fdata;

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

  1203.                             audioOut[i] = fdata;

  1204. 

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

  1206.                             cvIn[i] = fdata;

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

  1208.                             cvOut[i] = fdata;

  1209. 

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

  1211. 

  1212.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1213.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1214.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1216. 

  1217.                         if (timeInfo.bbt.valid)

  1218.                         {

  1219.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1220.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1221.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1222. 

  1223.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1224.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1225. 

  1226.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1227.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1228.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1229.                         }

  1230. 

  1231.                         plugin->initBuffers();

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

  1233.                         plugin->unlock();

  1234.                     }

  1235. 

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

  1237.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1238.                     std::size_t curMidiDataPos = 0;

  1239. 

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

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

  1242. 

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

  1244.                     {

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

  1246.                         {

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

  1248. 

  1249.                             if (event.type == kEngineEventTypeNull)

  1250.                                 break;

  1251. 

  1252.                             if (event.type == kEngineEventTypeControl)

  1253.                             {

  1254.                                 uint8_t data[3];

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

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

  1257. 

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

  1259.                                     break;

  1260. 

  1261.                                 // set time

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

  1263.                                 midiData = midiData + 4;

  1264.                                 curMidiDataPos += 4;

  1265. 

  1266.                                 // set port

  1267.                                 *midiData++ = 0;

  1268.                                 ++curMidiDataPos;

  1269. 

  1270.                                 // set size

  1271.                                 *midiData++ = size;

  1272.                                 ++curMidiDataPos;

  1273. 

  1274.                                 // set data

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

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

  1277. 

  1278.                                 curMidiDataPos += size;

  1279.                             }

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

  1281.                             {

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

  1283. 

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

  1285.                                     break;

  1286. 

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

  1288. 

  1289.                                 // set time

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

  1291.                                 midiData += 4;

  1292.                                 curMidiDataPos += 4;

  1293. 

  1294.                                 // set port

  1295.                                 *midiData++ = _midiEvent.port;

  1296.                                 ++curMidiDataPos;

  1297. 

  1298.                                 // set size

  1299.                                 *midiData++ = _midiEvent.size;

  1300.                                 ++curMidiDataPos;

  1301. 

  1302.                                 // set data

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

  1304. 

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

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

  1307. 

  1308.                                 curMidiDataPos += _midiEvent.size;

  1309.                             }

  1310.                         }

  1311. 

  1312.                         if (curMidiDataPos != 0 &&

  1313.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1314.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1315. 

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

  1317.                     }

  1318. 

  1319.                 }   break;

  1320. 

  1321.                 case kPluginBridgeRtClientQuit: {

  1322.                     quitReceived = true;

  1323.                     signalThreadShouldExit();

  1324.                 }   break;

  1325.                 }

  1326.             }

  1327.         }

  1328. 

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

  1330. 

  1331.         if (! quitReceived)

  1332.         {

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

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

  1335. 

  1336.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1337.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1338.             fShmNonRtServerControl.writeUInt(messageSize);

  1339.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1340.             fShmNonRtServerControl.commitWrite();

  1341.         }

  1342.     }

  1343. 

  1344.     // called from process thread above

  1345.     EngineEvent* getNextFreeInputEvent() const noexcept

  1346.     {

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

  1348.         {

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

  1350. 

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

  1352.                 return event;

  1353.         }

  1354.         return nullptr;

  1355.     }

  1356. 

  1357.     void latencyChanged(const uint32_t samples) noexcept override

  1358.     {

  1359.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1360. 

  1361.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1362.         fShmNonRtServerControl.writeUInt(samples);

  1363.         fShmNonRtServerControl.commitWrite();

  1364.     }

  1365. 

  1366.     // -------------------------------------------------------------------

  1367. 

  1368. private:

  1369.     BridgeAudioPool          fShmAudioPool;

  1370.     BridgeRtClientControl    fShmRtClientControl;

  1371.     BridgeNonRtClientControl fShmNonRtClientControl;

  1372.     BridgeNonRtServerControl fShmNonRtServerControl;

  1373. 

  1374.     CarlaString fBaseNameAudioPool;

  1375.     CarlaString fBaseNameRtClientControl;

  1376.     CarlaString fBaseNameNonRtClientControl;

  1377.     CarlaString fBaseNameNonRtServerControl;

  1378. 

  1379.     bool fIsOffline;

  1380.     bool fFirstIdle;

  1381.     int64_t fLastPingTime;

  1382. 

  1383.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1384. };

  1385. 

  1386. // -----------------------------------------------------------------------

  1387. 

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

  1389. {

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

  1391. }

  1392. 

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

  1394. 

  1395. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

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

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

  1400. #endif

  1401. 

  1402. CARLA_BACKEND_END_NAMESPACE

  1403. 

  1404. // -----------------------------------------------------------------------

  1405. 

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

  1407. extern "C" __declspec (dllexport)

  1408. #else

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

  1410. #endif

  1411. void carla_register_native_plugin_carla();

  1412. void carla_register_native_plugin_carla(){}

  1413. 

  1414. #include "CarlaBridgeUtils.cpp"

  1415. 

  1416. // -----------------------------------------------------------------------