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

1366 lines
55KB
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/water.h"

  35. 

  36. // must be last

  37. #include "jackbridge/JackBridge.hpp"

  38. 

  39. using water::File;

  40. using water::MemoryBlock;

  41. using water::String;

  42. using water::Time;

  43. 

  44. CARLA_BACKEND_START_NAMESPACE

  45. 

  46. // -----------------------------------------------------------------------

  47. // Bridge Engine client

  48. 

  49. struct LatencyChangedCallback {

  50.     virtual ~LatencyChangedCallback() noexcept {}

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

  52. };

  53. 

  54. class CarlaEngineBridgeClient : public CarlaEngineClient

  55. {

  56. public:

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

  58.         : CarlaEngineClient(engine),

  59.           fLatencyCallback(cb) {}

  60. 

  61. protected:

  62.     void setLatency(const uint32_t samples) noexcept override

  63.     {

  64.         if (getLatency() == samples)

  65.             return;

  66. 

  67.         fLatencyCallback->latencyChanged(samples);

  68.         CarlaEngineClient::setLatency(samples);

  69.     }

  70. 

  71. private:

  72.     LatencyChangedCallback* const fLatencyCallback;

  73. 

  74.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  75. };

  76. 

  77. // -------------------------------------------------------------------

  78. 

  79. class CarlaEngineBridge : public CarlaEngine,

  80.                           private CarlaThread,

  81.                           private LatencyChangedCallback

  82. {

  83. public:

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

  85.         : CarlaEngine(),

  86.           CarlaThread("CarlaEngineBridge"),

  87.           fShmAudioPool(),

  88.           fShmRtClientControl(),

  89.           fShmNonRtClientControl(),

  90.           fShmNonRtServerControl(),

  91.           fBaseNameAudioPool(audioPoolBaseName),

  92.           fBaseNameRtClientControl(rtClientBaseName),

  93.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  94.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  95.           fIsOffline(false),

  96.           fFirstIdle(true),

  97.           fLastPingTime(-1)

  98.     {

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

  100.     }

  101. 

  102.     ~CarlaEngineBridge() noexcept override

  103.     {

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

  105. 

  106.         clear();

  107.     }

  108. 

  109.     // -------------------------------------

  110.     // CarlaEngine virtual calls

  111. 

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

  113.     {

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

  115. 

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

  117.         {

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

  119.             return false;

  120.         }

  121. 

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

  123.         {

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

  125.             return false;

  126.         }

  127. 

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

  129.         {

  130.             clear();

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

  132.             return false;

  133.         }

  134. 

  135.         if (! fShmRtClientControl.mapData())

  136.         {

  137.             clear();

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

  139.             return false;

  140.         }

  141. 

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

  143.         {

  144.             clear();

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

  146.             return false;

  147.         }

  148. 

  149.         if (! fShmNonRtClientControl.mapData())

  150.         {

  151.             clear();

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

  153.             return false;

  154.         }

  155. 

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

  157.         {

  158.             clear();

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

  160.             return false;

  161.         }

  162. 

  163.         if (! fShmNonRtServerControl.mapData())

  164.         {

  165.             clear();

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

  167.             return false;

  168.         }

  169. 

  170.         PluginBridgeNonRtClientOpcode opcode;

  171. 

  172.         opcode = fShmNonRtClientControl.readOpcode();

  173.         CARLA_SAFE_ASSERT_INT(opcode == kPluginBridgeNonRtClientNull, opcode);

  174. 

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

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

  177. 

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

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

  180. 

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

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

  183. 

  184.         opcode = fShmNonRtClientControl.readOpcode();

  185.         CARLA_SAFE_ASSERT_INT(opcode == kPluginBridgeNonRtClientInitialSetup, opcode);

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

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

  188. 

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

  190.         {

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

  192.             return false;

  193.         }

  194. 

  195.         pData->initTime(nullptr);

  196. 

  197.         if (shmRtClientDataSize != sizeof(BridgeRtClientData) || shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) || shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  198.             return false;

  199. 

  200.         // tell backend we're live

  201.         {

  202.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  203. 

  204.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  205.             fShmNonRtServerControl.commitWrite();

  206.         }

  207. 

  208.         // TODO

  209.         startThread(/*Thread::realtimeAudioPriority*/);

  210. 

  211.         return true;

  212.     }

  213. 

  214.     bool close() override

  215.     {

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

  217.         fLastPingTime = -1;

  218. 

  219.         CarlaEngine::close();

  220. 

  221.         stopThread(5000);

  222.         clear();

  223. 

  224.         return true;

  225.     }

  226. 

  227.     bool isRunning() const noexcept override

  228.     {

  229.         return isThreadRunning() || ! fFirstIdle;

  230.     }

  231. 

  232.     bool isOffline() const noexcept override

  233.     {

  234.         return fIsOffline;

  235.     }

  236. 

  237.     EngineType getType() const noexcept override

  238.     {

  239.         return kEngineTypeBridge;

  240.     }

  241. 

  242.     const char* getCurrentDriverName() const noexcept override

  243.     {

  244.         return "Bridge";

  245.     }

  246. 

  247.     CarlaEngineClient* addClient(CarlaPlugin* const) override

  248.     {

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

  250.     }

  251. 

  252.     void idle() noexcept override

  253.     {

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

  255.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  256. 

  257.         const bool wasFirstIdle(fFirstIdle);

  258. 

  259.         if (wasFirstIdle)

  260.         {

  261.             fFirstIdle = false;

  262.             fLastPingTime = Time::currentTimeMillis();

  263.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  264. 

  265.             char bufStr[STR_MAX+1];

  266.             uint32_t bufStrSize;

  267. 

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

  269.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  270. 

  271.             // kPluginBridgeNonRtServerPluginInfo1

  272.             {

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

  274.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  280.                 fShmNonRtServerControl.commitWrite();

  281.             }

  282. 

  283.             // kPluginBridgeNonRtServerPluginInfo2

  284.             {

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

  286.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  287. 

  288.                 carla_zeroChars(bufStr, STR_MAX);

  289.                 plugin->getRealName(bufStr);

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

  291.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  292.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  293. 

  294.                 carla_zeroChars(bufStr, STR_MAX);

  295.                 plugin->getLabel(bufStr);

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

  297.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  298.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  299. 

  300.                 carla_zeroChars(bufStr, STR_MAX);

  301.                 plugin->getMaker(bufStr);

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

  303.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  304.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  305. 

  306.                 carla_zeroChars(bufStr, STR_MAX);

  307.                 plugin->getCopyright(bufStr);

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

  309.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  310.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  311. 

  312.                 fShmNonRtServerControl.commitWrite();

  313.             }

  314. 

  315.             // kPluginBridgeNonRtServerAudioCount

  316.             {

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

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

  319. 

  320.                 // uint/ins, uint/outs

  321.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  322.                 fShmNonRtServerControl.writeUInt(aIns);

  323.                 fShmNonRtServerControl.writeUInt(aOuts);

  324.                 fShmNonRtServerControl.commitWrite();

  325. 

  326.                 // kPluginBridgeNonRtServerPortName

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

  328.                 {

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

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

  331. 

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

  333.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  334.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  335.                     fShmNonRtServerControl.writeUInt(i);

  336. 

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

  338.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  339.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  340.                 }

  341. 

  342.                 // kPluginBridgeNonRtServerPortName

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

  344.                 {

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

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

  347. 

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

  349.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  350.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  351.                     fShmNonRtServerControl.writeUInt(i);

  352. 

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

  354.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  355.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  356.                 }

  357.             }

  358. 

  359.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  360. 

  361.             // kPluginBridgeNonRtServerMidiCount

  362.             {

  363.                 // uint/ins, uint/outs

  364.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  367.                 fShmNonRtServerControl.commitWrite();

  368.             }

  369. 

  370.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  371. 

  372.             // kPluginBridgeNonRtServerCvCount

  373.             {

  374.                 // uint/ins, uint/outs

  375.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  378.                 fShmNonRtServerControl.commitWrite();

  379.             }

  380. 

  381.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  382. 

  383.             // kPluginBridgeNonRtServerParameter*

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

  385.             {

  386.                 // uint/count

  387.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  388.                 fShmNonRtServerControl.writeUInt(count);

  389.                 fShmNonRtServerControl.commitWrite();

  390. 

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

  392.                 {

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

  394. 

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

  396.                         continue;

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

  398.                         continue;

  399. 

  400.                     // kPluginBridgeNonRtServerParameterData1

  401.                     {

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

  403.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  404.                         fShmNonRtServerControl.writeUInt(i);

  405.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  406.                         fShmNonRtServerControl.writeUInt(paramData.type);

  407.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  408.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  409.                         fShmNonRtServerControl.commitWrite();

  410.                     }

  411. 

  412.                     // kPluginBridgeNonRtServerParameterData2

  413.                     {

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

  415.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  416.                         fShmNonRtServerControl.writeUInt(i);

  417. 

  418.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  421.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  422.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  423. 

  424.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  427.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  428.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  429. 

  430.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  433.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  434.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  435. 

  436.                         fShmNonRtServerControl.commitWrite();

  437.                     }

  438. 

  439.                     // kPluginBridgeNonRtServerParameterRanges

  440.                     {

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

  442. 

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

  444.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  445.                         fShmNonRtServerControl.writeUInt(i);

  446.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  447.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  448.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  449.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  450.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  451.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  452.                         fShmNonRtServerControl.commitWrite();

  453.                     }

  454. 

  455.                     // kPluginBridgeNonRtServerParameterValue2

  456.                     {

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

  458.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  459.                         fShmNonRtServerControl.writeUInt(i);

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

  461.                         fShmNonRtServerControl.commitWrite();

  462.                     }

  463. 

  464.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  465.                 }

  466.             }

  467. 

  468.             // kPluginBridgeNonRtServerProgram*

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

  470.             {

  471.                 // uint/count

  472.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  473.                 fShmNonRtServerControl.writeUInt(count);

  474.                 fShmNonRtServerControl.commitWrite();

  475. 

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

  477.                 {

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

  479.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  480.                     fShmNonRtServerControl.writeUInt(i);

  481. 

  482.                     carla_zeroChars(bufStr, STR_MAX);

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

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

  485.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  486.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  487. 

  488.                     fShmNonRtServerControl.commitWrite();

  489.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  490.                 }

  491.             }

  492. 

  493.             // kPluginBridgeNonRtServerMidiProgram*

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

  495.             {

  496.                 // uint/count

  497.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  498.                 fShmNonRtServerControl.writeUInt(count);

  499.                 fShmNonRtServerControl.commitWrite();

  500. 

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

  502.                 {

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

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

  505. 

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

  507.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  508.                     fShmNonRtServerControl.writeUInt(i);

  509.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  510.                     fShmNonRtServerControl.writeUInt(mpData.program);

  511. 

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

  513.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  515. 

  516.                     fShmNonRtServerControl.commitWrite();

  517.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  518.                 }

  519.             }

  520. 

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

  522.             {

  523.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  524.                 fShmNonRtServerControl.writeUInt(latency);

  525.                 fShmNonRtServerControl.commitWrite();

  526.             }

  527. 

  528.             // ready!

  529.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  530.             fShmNonRtServerControl.commitWrite();

  531.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  532. 

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

  534.             fLastPingTime = Time::currentTimeMillis();

  535.         }

  536. 

  537.         // send parameter outputs

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

  539.         {

  540.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  541. 

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

  543.             {

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

  545.                     continue;

  546. 

  547.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  548.                 fShmNonRtServerControl.writeUInt(i);

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

  550. 

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

  552.                 if (! fShmNonRtServerControl.commitWrite())

  553.                     break;

  554.             }

  555.         }

  556. 

  557.         CarlaEngine::idle();

  558. 

  559.         try {

  560.             handleNonRtData();

  561.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  562. 

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

  564.         {

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

  566.             signalThreadShouldExit();

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

  568.         }

  569.     }

  570. 

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

  572.     {

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

  574. 

  575.         if (fLastPingTime < 0)

  576.             return;

  577. 

  578.         switch (action)

  579.         {

  580.         // uint/index float/value

  581.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  582.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  583.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  584.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  586.             fShmNonRtServerControl.writeFloat(value3);

  587.             fShmNonRtServerControl.commitWrite();

  588.         }   break;

  589. 

  590.         // uint/index float/value

  591.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  592.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  593.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  594.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  596.             fShmNonRtServerControl.writeFloat(value3);

  597.             fShmNonRtServerControl.commitWrite();

  598.         }   break;

  599. 

  600.         // int/index

  601.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  602.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  603.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  604.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  605.             fShmNonRtServerControl.writeInt(value1);

  606.             fShmNonRtServerControl.commitWrite();

  607.         }   break;

  608. 

  609.         // int/index

  610.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  611.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  612.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  613.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  614.             fShmNonRtServerControl.writeInt(value1);

  615.             fShmNonRtServerControl.commitWrite();

  616.         }   break;

  617. 

  618.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  619.             if (value1 != 1)

  620.             {

  621.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  622.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  623.                 fShmNonRtServerControl.commitWrite();

  624.             }

  625.             break;

  626. 

  627.         default:

  628.             break;

  629.         }

  630.     }

  631. 

  632.     // -------------------------------------------------------------------

  633. 

  634.     void clear() noexcept

  635.     {

  636.         fShmAudioPool.clear();

  637.         fShmRtClientControl.clear();

  638.         fShmNonRtClientControl.clear();

  639.         fShmNonRtServerControl.clear();

  640.     }

  641. 

  642.     void handleNonRtData()

  643.     {

  644.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  645.         {

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

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

  648. 

  649. #ifdef DEBUG

  650.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  652.             }

  653. #endif

  654. 

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

  656.                 fLastPingTime = Time::currentTimeMillis();

  657. 

  658.             switch (opcode)

  659.             {

  660.             case kPluginBridgeNonRtClientNull:

  661.                 break;

  662. 

  663.             case kPluginBridgeNonRtClientPing: {

  664.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  665. 

  666.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  667.                 fShmNonRtServerControl.commitWrite();

  668.             }   break;

  669. 

  670.             case kPluginBridgeNonRtClientPingOnOff: {

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

  672. 

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

  674.             }   break;

  675. 

  676.             case kPluginBridgeNonRtClientActivate:

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

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

  679.                 break;

  680. 

  681.             case kPluginBridgeNonRtClientDeactivate:

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

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

  684.                 break;

  685. 

  686.             case kPluginBridgeNonRtClientInitialSetup:

  687.                 // should never happen!!

  688.                 fShmNonRtServerControl.readUInt();

  689.                 fShmNonRtServerControl.readDouble();

  690.                 break;

  691. 

  692.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  695. 

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

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

  698.                 break;

  699.             }

  700. 

  701.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  704. 

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

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

  707.                 break;

  708.             }

  709. 

  710.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  713. 

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

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

  716.                 break;

  717.             }

  718. 

  719.             case kPluginBridgeNonRtClientSetProgram: {

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

  721. 

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

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

  724.                 break;

  725.             }

  726. 

  727.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  729. 

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

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

  732.                 break;

  733.             }

  734. 

  735.             case kPluginBridgeNonRtClientSetCustomData: {

  736.                 // type

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

  738.                 char typeStr[typeSize+1];

  739.                 carla_zeroChars(typeStr, typeSize+1);

  740.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  741. 

  742.                 // key

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

  744.                 char keyStr[keySize+1];

  745.                 carla_zeroChars(keyStr, keySize+1);

  746.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  747. 

  748.                 // value

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

  750.                 char valueStr[valueSize+1];

  751.                 carla_zeroChars(valueStr, valueSize+1);

  752.                 fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  753. 

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

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

  756.                 break;

  757.             }

  758. 

  759.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  761.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  762. 

  763.                 char chunkFilePathTry[size+1];

  764.                 carla_zeroChars(chunkFilePathTry, size+1);

  765.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  766. 

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

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

  769. 

  770.                 String chunkFilePath(chunkFilePathTry);

  771. 

  772. #ifdef CARLA_OS_WIN

  773.                 // check if running under Wine

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

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

  776. #endif

  777. 

  778.                 File chunkFile(chunkFilePath);

  779.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  780. 

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

  782.                 chunkFile.deleteFile();

  783.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  784. 

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

  786. 

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

  788.                 break;

  789.             }

  790. 

  791.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  794. 

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

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

  797.                 break;

  798.             }

  799. 

  800.             case kPluginBridgeNonRtClientSetOption: {

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

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

  803. 

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

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

  806.                 break;

  807.             }

  808. 

  809.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  811. 

  812.                 plugin->prepareForSave();

  813. 

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

  815.                 {

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

  817. 

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

  819.                         continue;

  820. 

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

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

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

  824. 

  825.                     {

  826.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  827. 

  828.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  829. 

  830.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  832. 

  833.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  835. 

  836.                         fShmNonRtServerControl.writeUInt(valueLen);

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

  838. 

  839.                         fShmNonRtServerControl.commitWrite();

  840.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  841.                     }

  842.                 }

  843. 

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

  845.                 {

  846.                     void* data = nullptr;

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

  848.                     {

  849.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  850. 

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

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

  853. 

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

  855. 

  856.                         filePath += CARLA_OS_SEP_STR;

  857.                         filePath += ".CarlaChunk_";

  858.                         filePath += fShmNonRtClientControl.filename.buffer() + 24;

  859. 

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

  861.                         {

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

  863. 

  864.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  865. 

  866.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  867.                             fShmNonRtServerControl.writeUInt(ulength);

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

  869.                             fShmNonRtServerControl.commitWrite();

  870.                         }

  871.                     }

  872.                 }

  873. 

  874.                 {

  875.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  876. 

  877.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  878.                     fShmNonRtServerControl.commitWrite();

  879.                 }

  880.                 break;

  881.             }

  882. 

  883.             case kPluginBridgeNonRtClientShowUI:

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

  885.                     plugin->showCustomUI(true);

  886.                 break;

  887. 

  888.             case kPluginBridgeNonRtClientHideUI:

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

  890.                     plugin->showCustomUI(false);

  891.                 break;

  892. 

  893.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  896. 

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

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

  899.                 break;

  900.             }

  901. 

  902.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  904. 

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

  906.                     plugin->uiProgramChange(index);

  907.                 break;

  908.             }

  909. 

  910.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  912. 

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

  914.                     plugin->uiMidiProgramChange(index);

  915.                 break;

  916.             }

  917. 

  918.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  922. 

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

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

  925.                 break;

  926.             }

  927. 

  928.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  931. 

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

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

  934.                 break;

  935.             }

  936. 

  937.             case kPluginBridgeNonRtClientQuit:

  938.                 signalThreadShouldExit();

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

  940.                 break;

  941.             }

  942.         }

  943.     }

  944. 

  945.     // -------------------------------------------------------------------

  946. 

  947. protected:

  948.     void run() override

  949.     {

  950. #ifdef __SSE2_MATH__

  951.         // Set FTZ and DAZ flags

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

  953. #endif

  954. 

  955.         bool quitReceived = false;

  956. 

  957.         for (; ! shouldThreadExit();)

  958.         {

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

  960. 

  961.             if (! helper.ok)

  962.                 continue;

  963. 

  964.             for (; fShmRtClientControl.isDataAvailableForReading();)

  965.             {

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

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

  968. 

  969. #ifdef DEBUG

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

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

  972.                 }

  973. #endif

  974. 

  975.                 switch (opcode)

  976.                 {

  977.                 case kPluginBridgeRtClientNull:

  978.                     break;

  979. 

  980.                 case kPluginBridgeRtClientSetAudioPool: {

  981.                     if (fShmAudioPool.data != nullptr)

  982.                     {

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

  984.                         fShmAudioPool.data = nullptr;

  985.                     }

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

  987.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  989.                     break;

  990.                 }

  991. 

  992.                 case kPluginBridgeRtClientSetBufferSize: {

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

  994.                     pData->bufferSize = bufferSize;

  995.                     bufferSizeChanged(bufferSize);

  996.                     break;

  997.                 }

  998. 

  999.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1001.                     pData->sampleRate = sampleRate;

  1002.                     sampleRateChanged(sampleRate);

  1003.                     break;

  1004.                 }

  1005. 

  1006.                 case kPluginBridgeRtClientSetOnline:

  1007.                     fIsOffline = fShmRtClientControl.readBool();

  1008.                     offlineModeChanged(fIsOffline);

  1009.                     break;

  1010. 

  1011.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1016. 

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

  1018.                     {

  1019.                         event->type    = kEngineEventTypeControl;

  1020.                         event->time    = time;

  1021.                         event->channel = channel;

  1022.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1023.                         event->ctrl.param = param;

  1024.                         event->ctrl.value = value;

  1025.                     }

  1026.                     break;

  1027.                 }

  1028. 

  1029.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1033. 

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

  1035.                     {

  1036.                         event->type    = kEngineEventTypeControl;

  1037.                         event->time    = time;

  1038.                         event->channel = channel;

  1039.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1040.                         event->ctrl.param = index;

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

  1042.                     }

  1043.                     break;

  1044.                 }

  1045. 

  1046.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1050. 

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

  1052.                     {

  1053.                         event->type    = kEngineEventTypeControl;

  1054.                         event->time    = time;

  1055.                         event->channel = channel;

  1056.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1057.                         event->ctrl.param = index;

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

  1059.                     }

  1060.                     break;

  1061.                 }

  1062. 

  1063.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1066. 

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

  1068.                     {

  1069.                         event->type    = kEngineEventTypeControl;

  1070.                         event->time    = time;

  1071.                         event->channel = channel;

  1072.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1073.                         event->ctrl.param = 0;

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

  1075.                     }

  1076.                 }   break;

  1077. 

  1078.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1081. 

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

  1083.                     {

  1084.                         event->type    = kEngineEventTypeControl;

  1085.                         event->time    = time;

  1086.                         event->channel = channel;

  1087.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1088.                         event->ctrl.param = 0;

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

  1090.                     }

  1091.                 }   break;

  1092. 

  1093.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1097.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1098. 

  1099.                     // FIXME variable-size stack

  1100.                     uint8_t data[size];

  1101. 

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

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

  1104. 

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

  1106.                     {

  1107.                         event->type    = kEngineEventTypeMidi;

  1108.                         event->time    = time;

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

  1110. 

  1111.                         event->midi.port = port;

  1112.                         event->midi.size = size;

  1113. 

  1114.                         if (size > EngineMidiEvent::kDataSize)

  1115.                         {

  1116.                             event->midi.dataExt = data;

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

  1118.                         }

  1119.                         else

  1120.                         {

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

  1122. 

  1123.                             uint8_t i=1;

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

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

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

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

  1128. 

  1129.                             event->midi.dataExt = nullptr;

  1130.                         }

  1131.                     }

  1132.                     break;

  1133.                 }

  1134. 

  1135.                 case kPluginBridgeRtClientProcess: {

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

  1137. 

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

  1139.                     {

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

  1141. 

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

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

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

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

  1146. 

  1147.                         const float* audioIn[audioInCount];

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

  1149.                         const float* cvIn[cvInCount];

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

  1151. 

  1152.                         float* fdata = fShmAudioPool.data;

  1153. 

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

  1155.                             audioIn[i] = fdata;

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

  1157.                             audioOut[i] = fdata;

  1158. 

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

  1160.                             cvIn[i] = fdata;

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

  1162.                             cvOut[i] = fdata;

  1163. 

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

  1165. 

  1166.                         timeInfo.playing = bridgeTimeInfo.playing;

  1167.                         timeInfo.frame   = bridgeTimeInfo.frame;

  1168.                         timeInfo.usecs   = bridgeTimeInfo.usecs;

  1169.                         timeInfo.valid   = bridgeTimeInfo.valid;

  1170. 

  1171.                         if (timeInfo.valid & EngineTimeInfo::kValidBBT)

  1172.                         {

  1173.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1174.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1175.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1176. 

  1177.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1178.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1179. 

  1180.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1181.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1182.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1183.                         }

  1184. 

  1185.                         plugin->initBuffers();

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

  1187.                         plugin->unlock();

  1188.                     }

  1189. 

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

  1191.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1192.                     std::size_t curMidiDataPos = 0;

  1193. 

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

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

  1196. 

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

  1198.                     {

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

  1200.                         {

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

  1202. 

  1203.                             if (event.type == kEngineEventTypeNull)

  1204.                                 break;

  1205. 

  1206.                             if (event.type == kEngineEventTypeControl)

  1207.                             {

  1208.                                 uint8_t size;

  1209.                                 uint8_t data[3];

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

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

  1212. 

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

  1214.                                     break;

  1215. 

  1216.                                 // set time

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

  1218.                                 midiData = midiData + 4;

  1219. 

  1220.                                 // set port

  1221.                                 *midiData++ = 0;

  1222. 

  1223.                                 // set size

  1224.                                 *midiData++ = size;

  1225. 

  1226.                                 // set data

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

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

  1229. 

  1230.                                 curMidiDataPos += kBridgeBaseMidiOutHeaderSize + size;

  1231.                             }

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

  1233.                             {

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

  1235. 

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

  1237.                                     break;

  1238. 

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

  1240. 

  1241.                                 // set time

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

  1243.                                 midiData += 4;

  1244. 

  1245.                                 // set port

  1246.                                 *midiData++ = _midiEvent.port;

  1247. 

  1248.                                 // set size

  1249.                                 *midiData++ = _midiEvent.size;

  1250. 

  1251.                                 // set data

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

  1253. 

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

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

  1256. 

  1257.                                 curMidiDataPos += kBridgeBaseMidiOutHeaderSize + _midiEvent.size;

  1258.                             }

  1259.                         }

  1260. 

  1261.                         if (curMidiDataPos != 0 &&

  1262.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1263.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1264. 

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

  1266.                     }

  1267. 

  1268.                 }   break;

  1269. 

  1270.                 case kPluginBridgeRtClientQuit: {

  1271.                     quitReceived = true;

  1272.                     signalThreadShouldExit();

  1273.                 }   break;

  1274.                 }

  1275.             }

  1276.         }

  1277. 

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

  1279. 

  1280.         if (! quitReceived)

  1281.         {

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

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

  1284. 

  1285.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1286.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1287.             fShmNonRtServerControl.writeUInt(messageSize);

  1288.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1289.             fShmNonRtServerControl.commitWrite();

  1290.         }

  1291.     }

  1292. 

  1293.     // called from process thread above

  1294.     EngineEvent* getNextFreeInputEvent() const noexcept

  1295.     {

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

  1297.         {

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

  1299. 

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

  1301.                 return event;

  1302.         }

  1303.         return nullptr;

  1304.     }

  1305. 

  1306.     void latencyChanged(const uint32_t samples) noexcept override

  1307.     {

  1308.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1309. 

  1310.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1311.         fShmNonRtServerControl.writeUInt(samples);

  1312.         fShmNonRtServerControl.commitWrite();

  1313.     }

  1314. 

  1315.     // -------------------------------------------------------------------

  1316. 

  1317. private:

  1318.     BridgeAudioPool          fShmAudioPool;

  1319.     BridgeRtClientControl    fShmRtClientControl;

  1320.     BridgeNonRtClientControl fShmNonRtClientControl;

  1321.     BridgeNonRtServerControl fShmNonRtServerControl;

  1322. 

  1323.     CarlaString fBaseNameAudioPool;

  1324.     CarlaString fBaseNameRtClientControl;

  1325.     CarlaString fBaseNameNonRtClientControl;

  1326.     CarlaString fBaseNameNonRtServerControl;

  1327. 

  1328.     bool fIsOffline;

  1329.     bool fFirstIdle;

  1330.     int64_t fLastPingTime;

  1331. 

  1332.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1333. };

  1334. 

  1335. // -----------------------------------------------------------------------

  1336. 

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

  1338. {

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

  1340. }

  1341. 

  1342. // -----------------------------------------------------------------------

  1343. 

  1344. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

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

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

  1349. #endif

  1350. 

  1351. CARLA_BACKEND_END_NAMESPACE

  1352. 

  1353. // -----------------------------------------------------------------------

  1354. 

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

  1356. extern "C" __declspec (dllexport)

  1357. #else

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

  1359. #endif

  1360. void carla_register_native_plugin_carla();

  1361. void carla_register_native_plugin_carla(){}

  1362. 

  1363. #include "CarlaBridgeUtils.cpp"

  1364. 

  1365. // -----------------------------------------------------------------------