falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3539 Commits
17 Branches
940MB
Tree: 918c049663
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '918c049663'
${ noResults }
Carla/source/backend/engine/CarlaEngineBridge.cpp

1533 lines
58KB
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. // must be last

  35. #include "jackbridge/JackBridge.hpp"

  36. 

  37. using juce::File;

  38. using juce::MemoryBlock;

  39. using juce::String;

  40. using juce::Time;

  41. using juce::Thread;

  42. 

  43. template<typename T>

  44. bool jackbridge_shm_map3(void* shm, T*& value) noexcept

  45. {

  46.     value = (T*)jackbridge_shm_map(shm, sizeof(T));

  47.     return (value != nullptr);

  48. }

  49. 

  50. CARLA_BACKEND_START_NAMESPACE

  51. 

  52. // -------------------------------------------------------------------

  53. 

  54. struct BridgeNonRtClientControl : public CarlaRingBufferControl<BigStackBuffer> {

  55.     CarlaString filename;

  56.     BridgeNonRtClientData* data;

  57.     char shm[64];

  58. 

  59.     BridgeNonRtClientControl() noexcept

  60.         : filename(),

  61.           data(nullptr)

  62.     {

  63.         carla_zeroChars(shm, 64);

  64.         jackbridge_shm_init(shm);

  65.     }

  66. 

  67.     ~BridgeNonRtClientControl() noexcept override

  68.     {

  69.         // should be cleared by now

  70.         CARLA_SAFE_ASSERT(data == nullptr);

  71. 

  72.         clear();

  73.     }

  74. 

  75.     void clear() noexcept

  76.     {

  77.         filename.clear();

  78. 

  79.         if (data != nullptr)

  80.             unmapData();

  81. 

  82.         if (! jackbridge_shm_is_valid(shm))

  83.         {

  84.             CARLA_SAFE_ASSERT(data == nullptr);

  85.             return;

  86.         }

  87. 

  88.         jackbridge_shm_close(shm);

  89.         jackbridge_shm_init(shm);

  90.     }

  91. 

  92.     bool attach() noexcept

  93.     {

  94.         // must be invalid right now

  95.         CARLA_SAFE_ASSERT_RETURN(! jackbridge_shm_is_valid(shm), false);

  96. 

  97.         jackbridge_shm_attach(shm, filename);

  98. 

  99.         return jackbridge_shm_is_valid(shm);

  100.     }

  101. 

  102.     bool mapData() noexcept

  103.     {

  104.         CARLA_SAFE_ASSERT(data == nullptr);

  105. 

  106.         if (jackbridge_shm_map3<BridgeNonRtClientData>(shm, data))

  107.         {

  108.             setRingBuffer(&data->ringBuffer, false);

  109.             return true;

  110.         }

  111. 

  112.         return false;

  113.     }

  114. 

  115.     void unmapData() noexcept

  116.     {

  117.         data = nullptr;

  118.         setRingBuffer(nullptr, false);

  119.     }

  120. 

  121.     PluginBridgeNonRtClientOpcode readOpcode() noexcept

  122.     {

  123.         return static_cast<PluginBridgeNonRtClientOpcode>(readUInt());

  124.     }

  125. 

  126.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtClientControl)

  127. };

  128. 

  129. // -------------------------------------------------------------------

  130. 

  131. struct BridgeNonRtServerControl : public CarlaRingBufferControl<HugeStackBuffer> {

  132.     CarlaMutex mutex;

  133.     CarlaString filename;

  134.     BridgeNonRtServerData* data;

  135.     char shm[64];

  136. 

  137.     BridgeNonRtServerControl() noexcept

  138.         :  mutex(),

  139.            filename(),

  140.            data(nullptr)

  141.     {

  142.         carla_zeroChars(shm, 64);

  143.         jackbridge_shm_init(shm);

  144.     }

  145. 

  146.     ~BridgeNonRtServerControl() noexcept override

  147.     {

  148.         // should be cleared by now

  149.         CARLA_SAFE_ASSERT(data == nullptr);

  150. 

  151.         clear();

  152.     }

  153. 

  154.     void clear() noexcept

  155.     {

  156.         filename.clear();

  157. 

  158.         if (data != nullptr)

  159.             unmapData();

  160. 

  161.         if (! jackbridge_shm_is_valid(shm))

  162.         {

  163.             CARLA_SAFE_ASSERT(data == nullptr);

  164.             return;

  165.         }

  166. 

  167.         jackbridge_shm_close(shm);

  168.         jackbridge_shm_init(shm);

  169.     }

  170. 

  171.     bool attach() noexcept

  172.     {

  173.         // must be invalid right now

  174.         CARLA_SAFE_ASSERT_RETURN(! jackbridge_shm_is_valid(shm), false);

  175. 

  176.         jackbridge_shm_attach(shm, filename);

  177. 

  178.         return jackbridge_shm_is_valid(shm);

  179.     }

  180. 

  181.     bool mapData() noexcept

  182.     {

  183.         CARLA_SAFE_ASSERT(data == nullptr);

  184. 

  185.         if (jackbridge_shm_map3<BridgeNonRtServerData>(shm, data))

  186.         {

  187.             setRingBuffer(&data->ringBuffer, false);

  188.             return true;

  189.         }

  190. 

  191.         return false;

  192.     }

  193. 

  194.     void unmapData() noexcept

  195.     {

  196.         data = nullptr;

  197.         setRingBuffer(nullptr, false);

  198.     }

  199. 

  200.     void writeOpcode(const PluginBridgeNonRtServerOpcode opcode) noexcept

  201.     {

  202.         writeUInt(static_cast<uint32_t>(opcode));

  203.     }

  204. 

  205.     void waitIfDataIsReachingLimit() noexcept

  206.     {

  207.         if (getAvailableDataSize() < HugeStackBuffer::size/4)

  208.             return;

  209. 

  210.         for (int i=50; --i >= 0;)

  211.         {

  212.             if (getAvailableDataSize() >= HugeStackBuffer::size*3/4)

  213.             {

  214.                 writeOpcode(kPluginBridgeNonRtServerPong);

  215.                 commitWrite();

  216.                 return;

  217.             }

  218.             carla_msleep(20);

  219.         }

  220. 

  221.         carla_stderr("Client waitIfDataIsReachingLimit() reached and failed");

  222.     }

  223. 

  224.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtServerControl)

  225. };

  226. 

  227. // -----------------------------------------------------------------------

  228. // Bridge Engine client

  229. 

  230. struct LatencyChangedCallback {

  231.     virtual ~LatencyChangedCallback() noexcept {}

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

  233. };

  234. 

  235. class CarlaEngineBridgeClient : public CarlaEngineClient

  236. {

  237. public:

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

  239.         : CarlaEngineClient(engine),

  240.           fLatencyCallback(cb) {}

  241. 

  242. protected:

  243.     void setLatency(const uint32_t samples) noexcept

  244.     {

  245.         if (getLatency() == samples)

  246.             return;

  247. 

  248.         fLatencyCallback->latencyChanged(samples);

  249.         CarlaEngineClient::setLatency(samples);

  250.     }

  251. 

  252. private:

  253.     LatencyChangedCallback* const fLatencyCallback;

  254. 

  255.     CARLA_DECLARE_NON_COPY_CLASS(CarlaEngineBridgeClient)

  256. };

  257. 

  258. // -------------------------------------------------------------------

  259. 

  260. class CarlaEngineBridge : public CarlaEngine,

  261.                           private Thread,

  262.                           private LatencyChangedCallback

  263. {

  264. public:

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

  266.         : CarlaEngine(),

  267.           Thread("CarlaEngineBridge"),

  268.           fShmAudioPool(),

  269.           fShmRtClientControl(),

  270.           fShmNonRtClientControl(),

  271.           fShmNonRtServerControl(),

  272.           fBaseNameAudioPool(audioPoolBaseName),

  273.           fBaseNameRtClientControl(rtClientBaseName),

  274.           fIsOffline(false),

  275.           fFirstIdle(true),

  276.           fLastPingTime(-1)

  277.     {

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

  279. 

  280.         fShmNonRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT;

  281.         fShmNonRtClientControl.filename += nonRtClientBaseName;

  282. 

  283.         fShmNonRtServerControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER;

  284.         fShmNonRtServerControl.filename += nonRtServerBaseName;

  285.     }

  286. 

  287.     ~CarlaEngineBridge() noexcept override

  288.     {

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

  290. 

  291.         clear();

  292.     }

  293. 

  294.     // -------------------------------------

  295.     // CarlaEngine virtual calls

  296. 

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

  298.     {

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

  300. 

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

  302.         {

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

  304.             return false;

  305.         }

  306. 

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

  308.         {

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

  310.             return false;

  311.         }

  312. 

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

  314.         {

  315.             clear();

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

  317.             return false;

  318.         }

  319. 

  320.         if (! fShmRtClientControl.mapData())

  321.         {

  322.             clear();

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

  324.             return false;

  325.         }

  326. 

  327.         if (! fShmNonRtClientControl.attach())

  328.         {

  329.             clear();

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

  331.             return false;

  332.         }

  333. 

  334.         if (! fShmNonRtClientControl.mapData())

  335.         {

  336.             clear();

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

  338.             return false;

  339.         }

  340. 

  341.         if (! fShmNonRtServerControl.attach())

  342.         {

  343.             clear();

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

  345.             return false;

  346.         }

  347. 

  348.         if (! fShmNonRtServerControl.mapData())

  349.         {

  350.             clear();

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

  352.             return false;

  353.         }

  354. 

  355.         PluginBridgeNonRtClientOpcode opcode;

  356. 

  357.         opcode = fShmNonRtClientControl.readOpcode();

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

  359. 

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

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

  362. 

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

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

  365. 

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

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

  368. 

  369.         opcode = fShmNonRtClientControl.readOpcode();

  370.         CARLA_SAFE_ASSERT_INT(opcode == kPluginBridgeNonRtClientSetBufferSize, opcode);

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

  372. 

  373.         opcode = fShmNonRtClientControl.readOpcode();

  374.         CARLA_SAFE_ASSERT_INT(opcode == kPluginBridgeNonRtClientSetSampleRate, opcode);

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

  376. 

  377.         pData->initTime(nullptr);

  378. 

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

  380.             return false;

  381. 

  382.         // tell backend we're live

  383.         {

  384.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  385. 

  386.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  387.             fShmNonRtServerControl.commitWrite();

  388.         }

  389. 

  390.         startThread(10);

  391. 

  392.         return true;

  393.     }

  394. 

  395.     bool close() override

  396.     {

  397.         carla_debug("CarlaEnginePlugin::close()");

  398.         fLastPingTime = -1;

  399. 

  400.         CarlaEngine::close();

  401. 

  402.         stopThread(5000);

  403.         clear();

  404. 

  405.         return true;

  406.     }

  407. 

  408.     bool isRunning() const noexcept override

  409.     {

  410.         return isThreadRunning() || ! fFirstIdle;

  411.     }

  412. 

  413.     bool isOffline() const noexcept override

  414.     {

  415.         return fIsOffline;

  416.     }

  417. 

  418.     EngineType getType() const noexcept override

  419.     {

  420.         return kEngineTypeBridge;

  421.     }

  422. 

  423.     const char* getCurrentDriverName() const noexcept override

  424.     {

  425.         return "Bridge";

  426.     }

  427. 

  428.     CarlaEngineClient* addClient(CarlaPlugin* const) override

  429.     {

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

  431.     }

  432. 

  433.     void idle() noexcept override

  434.     {

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

  436.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  437. 

  438.         const bool wasFirstIdle(fFirstIdle);

  439. 

  440.         if (wasFirstIdle)

  441.         {

  442.             fFirstIdle = false;

  443.             fLastPingTime = Time::currentTimeMillis();

  444.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  445. 

  446.             char bufStr[STR_MAX+1];

  447.             uint32_t bufStrSize;

  448. 

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

  450.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  451. 

  452.             // kPluginBridgeNonRtServerPluginInfo1

  453.             {

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

  455.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  461.                 fShmNonRtServerControl.commitWrite();

  462.             }

  463. 

  464.             // kPluginBridgeNonRtServerPluginInfo2

  465.             {

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

  467.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  468. 

  469.                 carla_zeroChars(bufStr, STR_MAX);

  470.                 plugin->getRealName(bufStr);

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

  472.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  473.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  474. 

  475.                 carla_zeroChars(bufStr, STR_MAX);

  476.                 plugin->getLabel(bufStr);

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

  478.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  479.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  480. 

  481.                 carla_zeroChars(bufStr, STR_MAX);

  482.                 plugin->getMaker(bufStr);

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

  484.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  485.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  486. 

  487.                 carla_zeroChars(bufStr, STR_MAX);

  488.                 plugin->getCopyright(bufStr);

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

  490.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  491.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  492. 

  493.                 fShmNonRtServerControl.commitWrite();

  494.             }

  495. 

  496.             // kPluginBridgeNonRtServerAudioCount

  497.             {

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

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

  500. 

  501.                 // uint/ins, uint/outs

  502.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  503.                 fShmNonRtServerControl.writeUInt(aIns);

  504.                 fShmNonRtServerControl.writeUInt(aOuts);

  505.                 fShmNonRtServerControl.commitWrite();

  506. 

  507.                 // kPluginBridgeNonRtServerPortName

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

  509.                 {

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

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

  512. 

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

  514.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  515.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  516.                     fShmNonRtServerControl.writeUInt(i);

  517. 

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

  519.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  520.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  521.                 }

  522. 

  523.                 // kPluginBridgeNonRtServerPortName

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

  525.                 {

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

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

  528. 

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

  530.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  531.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  532.                     fShmNonRtServerControl.writeUInt(i);

  533. 

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

  535.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  536.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  537.                 }

  538.             }

  539. 

  540.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  541. 

  542.             // kPluginBridgeNonRtServerMidiCount

  543.             {

  544.                 // uint/ins, uint/outs

  545.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  548.                 fShmNonRtServerControl.commitWrite();

  549.             }

  550. 

  551.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  552. 

  553.             // kPluginBridgeNonRtServerCvCount

  554.             {

  555.                 // uint/ins, uint/outs

  556.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  559.                 fShmNonRtServerControl.commitWrite();

  560.             }

  561. 

  562.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  563. 

  564.             // kPluginBridgeNonRtServerParameter*

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

  566.             {

  567.                 // uint/count

  568.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  569.                 fShmNonRtServerControl.writeUInt(count);

  570.                 fShmNonRtServerControl.commitWrite();

  571. 

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

  573.                 {

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

  575. 

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

  577.                         continue;

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

  579.                         continue;

  580. 

  581.                     // kPluginBridgeNonRtServerParameterData1

  582.                     {

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

  584.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  585.                         fShmNonRtServerControl.writeUInt(i);

  586.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  587.                         fShmNonRtServerControl.writeUInt(paramData.type);

  588.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  589.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  590.                         fShmNonRtServerControl.commitWrite();

  591.                     }

  592. 

  593.                     // kPluginBridgeNonRtServerParameterData2

  594.                     {

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

  596.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  597.                         fShmNonRtServerControl.writeUInt(i);

  598. 

  599.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  602.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  603.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  604. 

  605.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  608.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  609.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  610. 

  611.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  614.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  615.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  616. 

  617.                         fShmNonRtServerControl.commitWrite();

  618.                     }

  619. 

  620.                     // kPluginBridgeNonRtServerParameterRanges

  621.                     {

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

  623. 

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

  625.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  626.                         fShmNonRtServerControl.writeUInt(i);

  627.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  628.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  629.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  630.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  631.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  632.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  633.                         fShmNonRtServerControl.commitWrite();

  634.                     }

  635. 

  636.                     // kPluginBridgeNonRtServerParameterValue2

  637.                     {

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

  639.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  640.                         fShmNonRtServerControl.writeUInt(i);

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

  642.                         fShmNonRtServerControl.commitWrite();

  643.                     }

  644. 

  645.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  646.                 }

  647.             }

  648. 

  649.             // kPluginBridgeNonRtServerProgram*

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

  651.             {

  652.                 // uint/count

  653.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  654.                 fShmNonRtServerControl.writeUInt(count);

  655.                 fShmNonRtServerControl.commitWrite();

  656. 

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

  658.                 {

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

  660.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  661.                     fShmNonRtServerControl.writeUInt(i);

  662. 

  663.                     carla_zeroChars(bufStr, STR_MAX);

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

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

  666.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  667.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  668. 

  669.                     fShmNonRtServerControl.commitWrite();

  670.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  671.                 }

  672.             }

  673. 

  674.             // kPluginBridgeNonRtServerMidiProgram*

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

  676.             {

  677.                 // uint/count

  678.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  679.                 fShmNonRtServerControl.writeUInt(count);

  680.                 fShmNonRtServerControl.commitWrite();

  681. 

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

  683.                 {

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

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

  686. 

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

  688.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  689.                     fShmNonRtServerControl.writeUInt(i);

  690.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  691.                     fShmNonRtServerControl.writeUInt(mpData.program);

  692. 

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

  694.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  696. 

  697.                     fShmNonRtServerControl.commitWrite();

  698.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  699.                 }

  700.             }

  701. 

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

  703.             {

  704.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  705.                 fShmNonRtServerControl.writeUInt(latency);

  706.                 fShmNonRtServerControl.commitWrite();

  707.             }

  708. 

  709.             // ready!

  710.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  711.             fShmNonRtServerControl.commitWrite();

  712.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  713. 

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

  715.             fLastPingTime = Time::currentTimeMillis();

  716.         }

  717. 

  718.         // send parameter outputs

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

  720.         {

  721.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  722. 

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

  724.             {

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

  726.                     continue;

  727. 

  728.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  729.                 fShmNonRtServerControl.writeUInt(i);

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

  731. 

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

  733.                 if (! fShmNonRtServerControl.commitWrite())

  734.                     break;

  735.             }

  736.         }

  737. 

  738.         CarlaEngine::idle();

  739. 

  740.         try {

  741.             handleNonRtData();

  742.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  743. 

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

  745.         {

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

  747.             threadShouldExit();

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

  749.         }

  750.     }

  751. 

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

  753.     {

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

  755. 

  756.         if (fLastPingTime < 0)

  757.             return;

  758. 

  759.         switch (action)

  760.         {

  761.         // uint/index float/value

  762.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  763.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  764.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  765.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  767.             fShmNonRtServerControl.writeFloat(value3);

  768.             fShmNonRtServerControl.commitWrite();

  769.         }   break;

  770. 

  771.         // uint/index float/value

  772.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  773.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  774.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  775.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  777.             fShmNonRtServerControl.writeFloat(value3);

  778.             fShmNonRtServerControl.commitWrite();

  779.         }   break;

  780. 

  781.         // int/index

  782.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  783.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  784.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  785.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  786.             fShmNonRtServerControl.writeInt(value1);

  787.             fShmNonRtServerControl.commitWrite();

  788.         }   break;

  789. 

  790.         // int/index

  791.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  792.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  793.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  794.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  795.             fShmNonRtServerControl.writeInt(value1);

  796.             fShmNonRtServerControl.commitWrite();

  797.         }   break;

  798. 

  799.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  800.             if (value1 != 1)

  801.             {

  802.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  803.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  804.                 fShmNonRtServerControl.commitWrite();

  805.             }

  806.             break;

  807. 

  808.         default:

  809.             break;

  810.         }

  811.     }

  812. 

  813.     // -------------------------------------------------------------------

  814. 

  815.     void clear() noexcept

  816.     {

  817.         fShmAudioPool.clear();

  818.         fShmRtClientControl.clear();

  819.         fShmNonRtClientControl.clear();

  820.         fShmNonRtServerControl.clear();

  821.     }

  822. 

  823.     void handleNonRtData()

  824.     {

  825.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  826.         {

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

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

  829. 

  830. #ifdef DEBUG

  831.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  833.             }

  834. #endif

  835. 

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

  837.                 fLastPingTime = Time::currentTimeMillis();

  838. 

  839.             switch (opcode)

  840.             {

  841.             case kPluginBridgeNonRtClientNull:

  842.                 break;

  843. 

  844.             case kPluginBridgeNonRtClientPing: {

  845.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  846. 

  847.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  848.                 fShmNonRtServerControl.commitWrite();

  849.             }   break;

  850. 

  851.             case kPluginBridgeNonRtClientPingOnOff: {

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

  853. 

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

  855.             }   break;

  856. 

  857.             case kPluginBridgeNonRtClientActivate:

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

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

  860.                 break;

  861. 

  862.             case kPluginBridgeNonRtClientDeactivate:

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

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

  865.                 break;

  866. 

  867.             case kPluginBridgeNonRtClientSetBufferSize: {

  868.                 const uint32_t bufferSize(fShmNonRtClientControl.readUInt());

  869.                 pData->bufferSize = bufferSize;

  870.                 bufferSizeChanged(bufferSize);

  871.                 break;

  872.             }

  873. 

  874.             case kPluginBridgeNonRtClientSetSampleRate: {

  875.                 const double sampleRate(fShmNonRtClientControl.readDouble());

  876.                 pData->sampleRate = sampleRate;

  877.                 sampleRateChanged(sampleRate);

  878.                 break;

  879.             }

  880. 

  881.             case kPluginBridgeNonRtClientSetOffline:

  882.                 fIsOffline = true;

  883.                 offlineModeChanged(true);

  884.                 break;

  885. 

  886.             case kPluginBridgeNonRtClientSetOnline:

  887.                 fIsOffline = false;

  888.                 offlineModeChanged(false);

  889.                 break;

  890. 

  891.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  894. 

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

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

  897.                 break;

  898.             }

  899. 

  900.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  903. 

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

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

  906.                 break;

  907.             }

  908. 

  909.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  912. 

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

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

  915.                 break;

  916.             }

  917. 

  918.             case kPluginBridgeNonRtClientSetProgram: {

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

  920. 

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

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

  923.                 break;

  924.             }

  925. 

  926.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  928. 

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

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

  931.                 break;

  932.             }

  933. 

  934.             case kPluginBridgeNonRtClientSetCustomData: {

  935.                 // type

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

  937.                 char typeStr[typeSize+1];

  938.                 carla_zeroChars(typeStr, typeSize+1);

  939.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  940. 

  941.                 // key

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

  943.                 char keyStr[keySize+1];

  944.                 carla_zeroChars(keyStr, keySize+1);

  945.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  946. 

  947.                 // value

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

  949.                 char valueStr[valueSize+1];

  950.                 carla_zeroChars(valueStr, valueSize+1);

  951.                 fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  952. 

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

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

  955.                 break;

  956.             }

  957. 

  958.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  960.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  961. 

  962.                 char chunkFilePathTry[size+1];

  963.                 carla_zeroChars(chunkFilePathTry, size+1);

  964.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  965. 

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

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

  968. 

  969.                 String chunkFilePath(chunkFilePathTry);

  970. 

  971. #ifdef CARLA_OS_WIN

  972.                 // check if running under Wine

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

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

  975. #endif

  976. 

  977.                 File chunkFile(chunkFilePath);

  978.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  979. 

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

  981.                 chunkFile.deleteFile();

  982.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  983. 

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

  985. 

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

  987.                 break;

  988.             }

  989. 

  990.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  993. 

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

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

  996.                 break;

  997.             }

  998. 

  999.             case kPluginBridgeNonRtClientSetOption: {

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

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

  1002. 

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

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

  1005.                 break;

  1006.             }

  1007. 

  1008.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1010. 

  1011.                 plugin->prepareForSave();

  1012. 

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

  1014.                 {

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

  1016. 

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

  1018.                         continue;

  1019. 

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

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

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

  1023. 

  1024.                     {

  1025.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1026. 

  1027.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1028. 

  1029.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1031. 

  1032.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1034. 

  1035.                         fShmNonRtServerControl.writeUInt(valueLen);

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

  1037. 

  1038.                         fShmNonRtServerControl.commitWrite();

  1039.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1040.                     }

  1041.                 }

  1042. 

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

  1044.                 {

  1045.                     void* data = nullptr;

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

  1047.                     {

  1048.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1049. 

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

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

  1052. 

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

  1054. 

  1055.                         filePath += CARLA_OS_SEP_STR;

  1056.                         filePath += ".CarlaChunk_";

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

  1058. 

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

  1060.                         {

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

  1062. 

  1063.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1064. 

  1065.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1066.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1068.                             fShmNonRtServerControl.commitWrite();

  1069.                         }

  1070.                     }

  1071.                 }

  1072. 

  1073.                 {

  1074.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1075. 

  1076.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1077.                     fShmNonRtServerControl.commitWrite();

  1078.                 }

  1079.                 break;

  1080.             }

  1081. 

  1082.             case kPluginBridgeNonRtClientShowUI:

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

  1084.                     plugin->showCustomUI(true);

  1085.                 break;

  1086. 

  1087.             case kPluginBridgeNonRtClientHideUI:

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

  1089.                     plugin->showCustomUI(false);

  1090.                 break;

  1091. 

  1092.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1095. 

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

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

  1098.                 break;

  1099.             }

  1100. 

  1101.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1103. 

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

  1105.                     plugin->uiProgramChange(index);

  1106.                 break;

  1107.             }

  1108. 

  1109.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1111. 

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

  1113.                     plugin->uiMidiProgramChange(index);

  1114.                 break;

  1115.             }

  1116. 

  1117.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1121. 

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

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

  1124.                 break;

  1125.             }

  1126. 

  1127.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1130. 

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

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

  1133.                 break;

  1134.             }

  1135. 

  1136.             case kPluginBridgeNonRtClientQuit:

  1137.                 signalThreadShouldExit();

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

  1139.                 break;

  1140.             }

  1141.         }

  1142.     }

  1143. 

  1144.     // -------------------------------------------------------------------

  1145. 

  1146. protected:

  1147.     void run() override

  1148.     {

  1149. #ifdef __SSE2_MATH__

  1150.         // Set FTZ and DAZ flags

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

  1152. #endif

  1153. 

  1154.         bool quitReceived = false;

  1155. 

  1156.         for (; ! threadShouldExit();)

  1157.         {

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

  1159. 

  1160.             if (! helper.ok)

  1161.                 continue;

  1162. 

  1163.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1164.             {

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

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

  1167. 

  1168. #ifdef DEBUG

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

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

  1171.                 }

  1172. #endif

  1173. 

  1174.                 switch (opcode)

  1175.                 {

  1176.                 case kPluginBridgeRtClientNull:

  1177.                     break;

  1178. 

  1179.                 case kPluginBridgeRtClientSetAudioPool: {

  1180.                     if (fShmAudioPool.data != nullptr)

  1181.                     {

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

  1183.                         fShmAudioPool.data = nullptr;

  1184.                     }

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

  1186.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1188.                     break;

  1189.                 }

  1190. 

  1191.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1196. 

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

  1198.                     {

  1199.                         event->type    = kEngineEventTypeControl;

  1200.                         event->time    = time;

  1201.                         event->channel = channel;

  1202.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1203.                         event->ctrl.param = param;

  1204.                         event->ctrl.value = value;

  1205.                     }

  1206.                     break;

  1207.                 }

  1208. 

  1209.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1213. 

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

  1215.                     {

  1216.                         event->type    = kEngineEventTypeControl;

  1217.                         event->time    = time;

  1218.                         event->channel = channel;

  1219.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1220.                         event->ctrl.param = index;

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

  1222.                     }

  1223.                     break;

  1224.                 }

  1225. 

  1226.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1230. 

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

  1232.                     {

  1233.                         event->type    = kEngineEventTypeControl;

  1234.                         event->time    = time;

  1235.                         event->channel = channel;

  1236.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1237.                         event->ctrl.param = index;

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

  1239.                     }

  1240.                     break;

  1241.                 }

  1242. 

  1243.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1246. 

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

  1248.                     {

  1249.                         event->type    = kEngineEventTypeControl;

  1250.                         event->time    = time;

  1251.                         event->channel = channel;

  1252.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1253.                         event->ctrl.param = 0;

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

  1255.                     }

  1256.                 }   break;

  1257. 

  1258.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1261. 

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

  1263.                     {

  1264.                         event->type    = kEngineEventTypeControl;

  1265.                         event->time    = time;

  1266.                         event->channel = channel;

  1267.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1268.                         event->ctrl.param = 0;

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

  1270.                     }

  1271.                 }   break;

  1272. 

  1273.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1277.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1278. 

  1279.                     uint8_t data[size];

  1280. 

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

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

  1283. 

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

  1285.                     {

  1286.                         event->type    = kEngineEventTypeMidi;

  1287.                         event->time    = time;

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

  1289. 

  1290.                         event->midi.port = port;

  1291.                         event->midi.size = size;

  1292. 

  1293.                         if (size > EngineMidiEvent::kDataSize)

  1294.                         {

  1295.                             event->midi.dataExt = data;

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

  1297.                         }

  1298.                         else

  1299.                         {

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

  1301. 

  1302.                             uint8_t i=1;

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

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

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

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

  1307. 

  1308.                             event->midi.dataExt = nullptr;

  1309.                         }

  1310.                     }

  1311.                     break;

  1312.                 }

  1313. 

  1314.                 case kPluginBridgeRtClientProcess: {

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

  1316. 

  1317.                     if (plugin != nullptr && plugin->isEnabled() && plugin->tryLock(false))

  1318.                     {

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

  1320. 

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

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

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

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

  1325. 

  1326.                         const float* audioIn[audioInCount];

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

  1328.                         const float* cvIn[cvInCount];

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

  1330. 

  1331.                         float* fdata = fShmAudioPool.data;

  1332. 

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

  1334.                             audioIn[i] = fdata;

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

  1336.                             audioOut[i] = fdata;

  1337. 

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

  1339.                             cvIn[i] = fdata;

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

  1341.                             cvOut[i] = fdata;

  1342. 

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

  1344. 

  1345.                         timeInfo.playing = bridgeTimeInfo.playing;

  1346.                         timeInfo.frame   = bridgeTimeInfo.frame;

  1347.                         timeInfo.usecs   = bridgeTimeInfo.usecs;

  1348.                         timeInfo.valid   = bridgeTimeInfo.valid;

  1349. 

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

  1351.                         {

  1352.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1353.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1354.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1355. 

  1356.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1357.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1358. 

  1359.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1360.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1361.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1362.                         }

  1363. 

  1364.                         plugin->initBuffers();

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

  1366.                         plugin->unlock();

  1367.                     }

  1368. 

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

  1370.                     carla_zeroBytes(midiData, kBridgeRtClientDataMidiOutSize);

  1371.                     std::size_t curMidiDataPos = 0;

  1372. 

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

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

  1375. 

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

  1377.                     {

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

  1379.                         {

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

  1381. 

  1382.                             if (event.type == kEngineEventTypeNull)

  1383.                                 break;

  1384. 

  1385.                             if (event.type == kEngineEventTypeControl)

  1386.                             {

  1387.                                 uint8_t size;

  1388.                                 uint8_t data[3];

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

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

  1391. 

  1392.                                 if (curMidiDataPos + 1U /* size*/ + 4U /* time */ + size >= kBridgeRtClientDataMidiOutSize)

  1393.                                     break;

  1394. 

  1395.                                 // set size

  1396.                                 *midiData++ = size;

  1397. 

  1398.                                 // set time

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

  1400.                                 midiData = midiData + 4;

  1401. 

  1402.                                 // set data

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

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

  1405. 

  1406.                                 curMidiDataPos += 1U /* size*/ + 4U /* time */ + size;

  1407.                             }

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

  1409.                             {

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

  1411. 

  1412.                                 if (curMidiDataPos + 1 /* size*/ + 4 /* time */ + _midiEvent.size >= kBridgeRtClientDataMidiOutSize)

  1413.                                     break;

  1414. 

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

  1416. 

  1417.                                 // set size

  1418.                                 *midiData++ = _midiEvent.size;

  1419. 

  1420.                                 // set time

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

  1422.                                 midiData = midiData + 4;

  1423. 

  1424.                                 // set data

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

  1426. 

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

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

  1429. 

  1430.                                 curMidiDataPos += 1U /* size*/ + 4U /* time */ + _midiEvent.size;

  1431.                             }

  1432.                         }

  1433. 

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

  1435.                     }

  1436. 

  1437.                 }   break;

  1438. 

  1439.                 case kPluginBridgeRtClientQuit: {

  1440.                     quitReceived = true;

  1441.                     signalThreadShouldExit();

  1442.                 }   break;

  1443.                 }

  1444.             }

  1445.         }

  1446. 

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

  1448. 

  1449.         if (! quitReceived)

  1450.         {

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

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

  1453. 

  1454.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1455.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1456.             fShmNonRtServerControl.writeUInt(messageSize);

  1457.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1458.             fShmNonRtServerControl.commitWrite();

  1459.         }

  1460.     }

  1461. 

  1462.     // called from process thread above

  1463.     EngineEvent* getNextFreeInputEvent() const noexcept

  1464.     {

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

  1466.         {

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

  1468. 

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

  1470.                 return event;

  1471.         }

  1472.         return nullptr;

  1473.     }

  1474. 

  1475.     void latencyChanged(const uint32_t samples) noexcept

  1476.     {

  1477.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1478. 

  1479.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1480.         fShmNonRtServerControl.writeUInt(samples);

  1481.         fShmNonRtServerControl.commitWrite();

  1482.     }

  1483. 

  1484.     // -------------------------------------------------------------------

  1485. 

  1486. private:

  1487.     BridgeAudioPool          fShmAudioPool;

  1488.     BridgeRtClientControl    fShmRtClientControl;

  1489.     BridgeNonRtClientControl fShmNonRtClientControl;

  1490.     BridgeNonRtServerControl fShmNonRtServerControl;

  1491. 

  1492.     CarlaString fBaseNameAudioPool;

  1493.     CarlaString fBaseNameRtClientControl;

  1494. 

  1495.     bool fIsOffline;

  1496.     bool fFirstIdle;

  1497.     int64_t fLastPingTime;

  1498. 

  1499.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1500. };

  1501. 

  1502. // -----------------------------------------------------------------------

  1503. 

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

  1505. {

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

  1507. }

  1508. 

  1509. // -----------------------------------------------------------------------

  1510. 

  1511. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

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

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

  1516. #endif

  1517. 

  1518. CARLA_BACKEND_END_NAMESPACE

  1519. 

  1520. // -----------------------------------------------------------------------

  1521. 

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

  1523. extern "C" __declspec (dllexport)

  1524. #else

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

  1526. #endif

  1527. void carla_register_native_plugin_carla();

  1528. void carla_register_native_plugin_carla(){}

  1529. 

  1530. #include "CarlaBridgeUtils.cpp"

  1531. 

  1532. // -----------------------------------------------------------------------