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

1679 lines
67KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2022 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. // must be first so we can undef CARLA_SAFE_*_RETURN_ERR* macros

  23. #include "CarlaPluginInternal.hpp"

  24. #undef CARLA_SAFE_ASSERT_RETURN_ERR

  25. #undef CARLA_SAFE_ASSERT_RETURN_ERRN

  26. #undef CARLA_SAFE_EXCEPTION_RETURN_ERR

  27. #undef CARLA_SAFE_EXCEPTION_RETURN_ERRN

  28. 

  29. #include "CarlaEngineClient.hpp"

  30. #include "CarlaEngineInit.hpp"

  31. 

  32. #include "CarlaBackendUtils.hpp"

  33. #include "CarlaBase64Utils.hpp"

  34. #include "CarlaBridgeUtils.hpp"

  35. #include "CarlaMIDI.h"

  36. 

  37. #ifdef __SSE2_MATH__

  38. # include <xmmintrin.h>

  39. #endif

  40. 

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

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

  43. 

  44. // must be last

  45. #include "jackbridge/JackBridge.hpp"

  46. 

  47. using water::File;

  48. using water::MemoryBlock;

  49. using water::String;

  50. using water::Time;

  51. 

  52. CARLA_BACKEND_START_NAMESPACE

  53. 

  54. // -----------------------------------------------------------------------

  55. // Bridge Engine client

  56. 

  57. struct LatencyChangedCallback {

  58.     virtual ~LatencyChangedCallback() noexcept {}

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

  60. };

  61. 

  62. class CarlaEngineBridgeClient : public CarlaEngineClientForSubclassing

  63. {

  64. public:

  65. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  66.     CarlaEngineBridgeClient(const CarlaEngine& engine,

  67.                             EngineInternalGraph& egraph,

  68.                             const CarlaPluginPtr plugin,

  69.                             LatencyChangedCallback* const cb)

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

  71.           fLatencyCallback(cb) {}

  72. #else

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

  74.         : CarlaEngineClientForSubclassing(engine),

  75.           fLatencyCallback(cb) {}

  76. #endif

  77. 

  78. protected:

  79.     void setLatency(const uint32_t samples) noexcept override

  80.     {

  81.         if (getLatency() == samples)

  82.             return;

  83. 

  84.         fLatencyCallback->latencyChanged(samples);

  85.         CarlaEngineClient::setLatency(samples);

  86.     }

  87. 

  88. private:

  89.     LatencyChangedCallback* const fLatencyCallback;

  90. 

  91.     CARLA_DECLARE_NON_COPYABLE(CarlaEngineBridgeClient)

  92. };

  93. 

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

  95. 

  96. class CarlaEngineBridge : public CarlaEngine,

  97.                           private CarlaThread,

  98.                           private LatencyChangedCallback

  99. {

  100. public:

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

  102.         : CarlaEngine(),

  103.           CarlaThread("CarlaEngineBridge"),

  104.           fShmAudioPool(),

  105.           fShmRtClientControl(),

  106.           fShmNonRtClientControl(),

  107.           fShmNonRtServerControl(),

  108.           fBaseNameAudioPool(audioPoolBaseName),

  109.           fBaseNameRtClientControl(rtClientBaseName),

  110.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  111.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  112.           fClosingDown(false),

  113.           fIsOffline(false),

  114.           fFirstIdle(true),

  115.           fLastPingTime(-1)

  116.     {

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

  118.     }

  119. 

  120.     ~CarlaEngineBridge() noexcept override

  121.     {

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

  123. 

  124.         clear();

  125.     }

  126. 

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

  128.     // CarlaEngine virtual calls

  129. 

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

  131.     {

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

  133. 

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

  135.         {

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

  137.             return false;

  138.         }

  139. 

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

  141.         {

  142.             pData->close();

  143.             setLastError("Failed to attach to audio pool shared memory");

  144.             return false;

  145.         }

  146. 

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

  148.         {

  149.             pData->close();

  150.             clear();

  151.             setLastError("Failed to attach to rt client control shared memory");

  152.             return false;

  153.         }

  154. 

  155.         if (! fShmRtClientControl.mapData())

  156.         {

  157.             pData->close();

  158.             clear();

  159.             setLastError("Failed to map rt client control shared memory");

  160.             return false;

  161.         }

  162. 

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

  164.         {

  165.             pData->close();

  166.             clear();

  167.             setLastError("Failed to attach to non-rt client control shared memory");

  168.             return false;

  169.         }

  170. 

  171.         if (! fShmNonRtClientControl.mapData())

  172.         {

  173.             pData->close();

  174.             clear();

  175.             setLastError("Failed to map non-rt control client shared memory");

  176.             return false;

  177.         }

  178. 

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

  180.         {

  181.             pData->close();

  182.             clear();

  183.             setLastError("Failed to attach to non-rt server control shared memory");

  184.             return false;

  185.         }

  186. 

  187.         if (! fShmNonRtServerControl.mapData())

  188.         {

  189.             pData->close();

  190.             clear();

  191.             setLastError("Failed to map non-rt control server shared memory");

  192.             return false;

  193.         }

  194. 

  195.         PluginBridgeNonRtClientOpcode opcode;

  196. 

  197.         opcode = fShmNonRtClientControl.readOpcode();

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

  199. 

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

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

  202. 

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

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

  205. 

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

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

  208. 

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

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

  211. 

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

  213.             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||

  214.             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  215.         {

  216.             pData->close();

  217.             clear();

  218.             setLastError("Shared memory data size mismatch");

  219.             return false;

  220.         }

  221. 

  222.         opcode = fShmNonRtClientControl.readOpcode();

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

  224. 

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

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

  227. 

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

  229.         {

  230.             pData->close();

  231.             clear();

  232.             setLastError("Shared memory has invalid data");

  233.             return false;

  234.         }

  235. 

  236.         pData->initTime(nullptr);

  237. 

  238.         // tell backend we're live

  239.         {

  240.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  241. 

  242.             // kPluginBridgeNonRtServerVersion was added in API 7

  243.             if (apiVersion >= 7)

  244.             {

  245.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);

  246.                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);

  247.             }

  248.             else

  249.             {

  250.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  251.             }

  252. 

  253.             fShmNonRtServerControl.commitWrite();

  254.         }

  255. 

  256.         startThread(true);

  257.         return true;

  258.     }

  259. 

  260.     bool close() override

  261.     {

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

  263.         fLastPingTime = -1;

  264. 

  265.         CarlaEngine::close();

  266. 

  267.         stopThread(5000);

  268.         clear();

  269. 

  270.         return true;

  271.     }

  272. 

  273.     bool isRunning() const noexcept override

  274.     {

  275.         if (fClosingDown)

  276.             return false;

  277. 

  278.         return isThreadRunning() || ! fFirstIdle;

  279.     }

  280. 

  281.     bool isOffline() const noexcept override

  282.     {

  283.         return fIsOffline;

  284.     }

  285. 

  286.     EngineType getType() const noexcept override

  287.     {

  288.         return kEngineTypeBridge;

  289.     }

  290. 

  291.     const char* getCurrentDriverName() const noexcept override

  292.     {

  293.         return "Bridge";

  294.     }

  295. 

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

  297.     {

  298.         CARLA_SAFE_ASSERT_RETURN(id == 0,);

  299. 

  300.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  301.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);

  302.         fShmNonRtServerControl.writeUInt(parameterId);

  303.         fShmNonRtServerControl.writeBool(touch);

  304.         fShmNonRtServerControl.commitWrite();

  305.     }

  306. 

  307.     CarlaEngineClient* addClient(const CarlaPluginPtr plugin) override

  308.     {

  309. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  311. #else

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

  313. 

  314.         // unused

  315.         (void)plugin;

  316. #endif

  317.     }

  318. 

  319.     void idle() noexcept override

  320.     {

  321.         const CarlaPluginPtr plugin = pData->plugins[0].plugin;

  322. 

  323.         if (plugin.get() == nullptr)

  324.         {

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

  326.             {

  327.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  328.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  329.                 fShmNonRtServerControl.writeUInt(length);

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

  331.                 fShmNonRtServerControl.commitWrite();

  332.             }

  333. 

  334.             signalThreadShouldExit();

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

  336.             return;

  337.         }

  338. 

  339.         const bool wasFirstIdle(fFirstIdle);

  340. 

  341.         if (wasFirstIdle)

  342.         {

  343.             fFirstIdle = false;

  344.             fLastPingTime = Time::currentTimeMillis();

  345.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  346. 

  347.             char bufStr[STR_MAX+1];

  348.             carla_zeroChars(bufStr, STR_MAX+1);

  349. 

  350.             uint32_t bufStrSize;

  351. 

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

  353.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  354. 

  355.             // kPluginBridgeNonRtServerPluginInfo1

  356.             {

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

  358.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  364.                 fShmNonRtServerControl.commitWrite();

  365.             }

  366. 

  367.             // kPluginBridgeNonRtServerPluginInfo2

  368.             {

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

  370.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  371. 

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

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

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

  375.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  376.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  377. 

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

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

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

  381.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  382.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  383. 

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

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

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

  387.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  388.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  389. 

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

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

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

  393.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  394.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  395. 

  396.                 fShmNonRtServerControl.commitWrite();

  397.             }

  398. 

  399.             // kPluginBridgeNonRtServerAudioCount

  400.             {

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

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

  403. 

  404.                 // uint/ins, uint/outs

  405.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  406.                 fShmNonRtServerControl.writeUInt(aIns);

  407.                 fShmNonRtServerControl.writeUInt(aOuts);

  408.                 fShmNonRtServerControl.commitWrite();

  409. 

  410.                 // kPluginBridgeNonRtServerPortName

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

  412.                 {

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

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

  415. 

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

  417.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  418.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  419.                     fShmNonRtServerControl.writeUInt(i);

  420. 

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

  422.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  423.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  424.                 }

  425. 

  426.                 // kPluginBridgeNonRtServerPortName

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

  428.                 {

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

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

  431. 

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

  433.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  434.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  435.                     fShmNonRtServerControl.writeUInt(i);

  436. 

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

  438.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  439.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  440.                 }

  441.             }

  442. 

  443.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  444. 

  445.             // kPluginBridgeNonRtServerMidiCount

  446.             {

  447.                 // uint/ins, uint/outs

  448.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  451.                 fShmNonRtServerControl.commitWrite();

  452.             }

  453. 

  454.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  455. 

  456.             // kPluginBridgeNonRtServerCvCount

  457.             {

  458.                 // uint/ins, uint/outs

  459.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  462.                 fShmNonRtServerControl.commitWrite();

  463.             }

  464. 

  465.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  466. 

  467.             // kPluginBridgeNonRtServerParameter*

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

  469.             {

  470.                 // uint/count

  471.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  472.                 fShmNonRtServerControl.writeUInt(count);

  473.                 fShmNonRtServerControl.commitWrite();

  474. 

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

  476.                 {

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

  478. 

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

  480.                         continue;

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

  482.                         continue;

  483. 

  484.                     // kPluginBridgeNonRtServerParameterData1

  485.                     {

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

  487.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  488.                         fShmNonRtServerControl.writeUInt(i);

  489.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  490.                         fShmNonRtServerControl.writeUInt(paramData.type);

  491.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  492.                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);

  493.                         fShmNonRtServerControl.commitWrite();

  494.                     }

  495. 

  496.                     // kPluginBridgeNonRtServerParameterData2

  497.                     {

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

  499.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  500.                         fShmNonRtServerControl.writeUInt(i);

  501. 

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

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

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

  505.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  506.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  507. 

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

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

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

  511.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  512.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  513. 

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

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

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

  517.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  518.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  519. 

  520.                         fShmNonRtServerControl.commitWrite();

  521.                     }

  522. 

  523.                     // kPluginBridgeNonRtServerParameterRanges

  524.                     {

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

  526. 

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

  528.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  529.                         fShmNonRtServerControl.writeUInt(i);

  530.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  531.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  532.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  533.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  534.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  535.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  536.                         fShmNonRtServerControl.commitWrite();

  537.                     }

  538. 

  539.                     // kPluginBridgeNonRtServerParameterValue2

  540.                     {

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

  542.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  543.                         fShmNonRtServerControl.writeUInt(i);

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

  545.                         fShmNonRtServerControl.commitWrite();

  546.                     }

  547. 

  548.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  549.                 }

  550.             }

  551. 

  552.             // kPluginBridgeNonRtServerProgram*

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

  554.             {

  555.                 // uint/count

  556.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  557.                 fShmNonRtServerControl.writeUInt(count);

  558.                 fShmNonRtServerControl.commitWrite();

  559. 

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

  561.                 {

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

  563.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  564.                     fShmNonRtServerControl.writeUInt(i);

  565. 

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

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

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

  569.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  570.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  571. 

  572.                     fShmNonRtServerControl.commitWrite();

  573.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  574.                 }

  575.             }

  576. 

  577.             // kPluginBridgeNonRtServerMidiProgram*

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

  579.             {

  580.                 // uint/count

  581.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  582.                 fShmNonRtServerControl.writeUInt(count);

  583.                 fShmNonRtServerControl.commitWrite();

  584. 

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

  586.                 {

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

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

  589. 

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

  591.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  592.                     fShmNonRtServerControl.writeUInt(i);

  593.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  594.                     fShmNonRtServerControl.writeUInt(mpData.program);

  595. 

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

  597.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  599. 

  600.                     fShmNonRtServerControl.commitWrite();

  601.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  602.                 }

  603.             }

  604. 

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

  606.             {

  607.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  608.                 fShmNonRtServerControl.writeUInt(latency);

  609.                 fShmNonRtServerControl.commitWrite();

  610.             }

  611. 

  612.             // ready!

  613.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  614.             fShmNonRtServerControl.commitWrite();

  615.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  616. 

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

  618.             fLastPingTime = Time::currentTimeMillis();

  619.         }

  620. 

  621.         // send parameter outputs

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

  623.         {

  624.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  625. 

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

  627.             {

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

  629.                     continue;

  630. 

  631.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  632.                 fShmNonRtServerControl.writeUInt(i);

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

  634. 

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

  636.                 if (! fShmNonRtServerControl.commitWrite())

  637.                     break;

  638.             }

  639.         }

  640. 

  641.         CarlaEngine::idle();

  642. 

  643.         try {

  644.             handleNonRtData();

  645.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  646. 

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

  648.         {

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

  650.             signalThreadShouldExit();

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

  652.         }

  653.     }

  654. 

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

  656.                   const EngineCallbackOpcode action, const uint pluginId,

  657.                   const int value1, const int value2, const int value3,

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

  659.     {

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

  661. 

  662.         if (fClosingDown || ! sendHost)

  663.             return;

  664. 

  665.         switch (action)

  666.         {

  667.         // uint/index float/value

  668.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  669.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  670.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  671.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  673.             fShmNonRtServerControl.writeFloat(valuef);

  674.             fShmNonRtServerControl.commitWrite();

  675.         }   break;

  676. 

  677.         // uint/index float/value

  678.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  679.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  680.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  681.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  683.             fShmNonRtServerControl.writeFloat(valuef);

  684.             fShmNonRtServerControl.commitWrite();

  685.         }   break;

  686. 

  687.         // int/index

  688.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  689.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  690.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  691.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  692.             fShmNonRtServerControl.writeInt(value1);

  693.             fShmNonRtServerControl.commitWrite();

  694.         }   break;

  695. 

  696.         // int/index

  697.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  698.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  699.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  700.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  701.             fShmNonRtServerControl.writeInt(value1);

  702.             fShmNonRtServerControl.commitWrite();

  703.         }   break;

  704. 

  705.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  706.             if (value1 != 1)

  707.             {

  708.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  709.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  710.                 fShmNonRtServerControl.commitWrite();

  711.             }

  712.             break;

  713. 

  714.         case ENGINE_CALLBACK_EMBED_UI_RESIZED: {

  715.             CARLA_SAFE_ASSERT_BREAK(value1 > 1);

  716.             CARLA_SAFE_ASSERT_BREAK(value2 > 1);

  717. 

  718.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  719. 

  720.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerResizeEmbedUI);

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

  722.             fShmNonRtServerControl.writeUInt(static_cast<uint>(value2));

  723.             fShmNonRtServerControl.commitWrite();

  724.         }   break;

  725. 

  726.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  727.             if (const CarlaPluginPtr plugin = pData->plugins[0].plugin)

  728.             {

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

  730.                 {

  731.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  732. 

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

  734.                     {

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

  736. 

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

  738.                             continue;

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

  740.                             continue;

  741. 

  742.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

  743.                         fShmNonRtServerControl.writeUInt(i);

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

  745.                         fShmNonRtServerControl.commitWrite();

  746. 

  747.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  748.                     }

  749.                 }

  750.             }

  751.             break;

  752. 

  753.         default:

  754.             break;

  755.         }

  756.     }

  757. 

  758.     // -------------------------------------------------------------------

  759. 

  760.     void clear() noexcept

  761.     {

  762.         fShmAudioPool.clear();

  763.         fShmRtClientControl.clear();

  764.         fShmNonRtClientControl.clear();

  765.         fShmNonRtServerControl.clear();

  766.     }

  767. 

  768.     void handleNonRtData()

  769.     {

  770.         const CarlaPluginPtr plugin = pData->plugins[0].plugin;

  771.         CARLA_SAFE_ASSERT_RETURN(plugin.get() != nullptr,);

  772. 

  773.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  774.         {

  775.             const PluginBridgeNonRtClientOpcode opcode = fShmNonRtClientControl.readOpcode();

  776. 

  777. #ifdef DEBUG

  778.             if (opcode != kPluginBridgeNonRtClientPing) {

  779.                 carla_debug("CarlaEngineBridge::handleNonRtData() - got opcode: %i:%s",

  780.                             opcode, PluginBridgeNonRtClientOpcode2str(opcode));

  781.             }

  782. #endif

  783. 

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

  785.                 fLastPingTime = Time::currentTimeMillis();

  786. 

  787.             switch (opcode)

  788.             {

  789.             case kPluginBridgeNonRtClientNull:

  790.                 break;

  791. 

  792.             case kPluginBridgeNonRtClientVersion: {

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

  794.                 CARLA_SAFE_ASSERT_UINT2(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,

  795.                                         apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);

  796.             }   break;

  797. 

  798.             case kPluginBridgeNonRtClientPing: {

  799.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  800. 

  801.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  802.                 fShmNonRtServerControl.commitWrite();

  803.             }   break;

  804. 

  805.             case kPluginBridgeNonRtClientPingOnOff: {

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

  807. 

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

  809.             }   break;

  810. 

  811.             case kPluginBridgeNonRtClientActivate:

  812.                 if (plugin->isEnabled())

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

  814.                 break;

  815. 

  816.             case kPluginBridgeNonRtClientDeactivate:

  817.                 if (plugin->isEnabled())

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

  819.                 break;

  820. 

  821.             case kPluginBridgeNonRtClientInitialSetup:

  822.                 // should never happen!!

  823.                 fShmNonRtServerControl.readUInt();

  824.                 fShmNonRtServerControl.readDouble();

  825.                 break;

  826. 

  827.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  830. 

  831.                 if (plugin->isEnabled())

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

  833.                 break;

  834.             }

  835. 

  836.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  839. 

  840.                 if (plugin->isEnabled())

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

  842.                 break;

  843.             }

  844. 

  845.             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {

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

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

  848. 

  849.                 if (plugin->isEnabled())

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

  851.                 break;

  852.             }

  853. 

  854.             case kPluginBridgeNonRtClientSetParameterMappedRange: {

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

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

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

  858. 

  859.                 if (plugin->isEnabled())

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

  861.                 break;

  862.             }

  863. 

  864.             case kPluginBridgeNonRtClientSetProgram: {

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

  866. 

  867.                 if (plugin->isEnabled())

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

  869.                 break;

  870.             }

  871. 

  872.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  874. 

  875.                 if (plugin->isEnabled())

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

  877.                 break;

  878.             }

  879. 

  880.             case kPluginBridgeNonRtClientSetCustomData: {

  881.                 // type

  882.                 const uint32_t typeSize = fShmNonRtClientControl.readUInt();

  883.                 char typeStr[typeSize+1];

  884.                 carla_zeroChars(typeStr, typeSize+1);

  885.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  886. 

  887.                 // key

  888.                 const uint32_t keySize = fShmNonRtClientControl.readUInt();

  889.                 char keyStr[keySize+1];

  890.                 carla_zeroChars(keyStr, keySize+1);

  891.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  892. 

  893.                 // value

  894.                 const uint32_t valueSize = fShmNonRtClientControl.readUInt();

  895. 

  896.                 if (valueSize > 0)

  897.                 {

  898.                     if (valueSize > 16384)

  899.                     {

  900.                         const uint32_t bigValueFilePathSize = fShmNonRtClientControl.readUInt();

  901.                         char bigValueFilePathTry[bigValueFilePathSize+1];

  902.                         carla_zeroChars(bigValueFilePathTry, bigValueFilePathSize+1);

  903.                         fShmNonRtClientControl.readCustomData(bigValueFilePathTry, bigValueFilePathSize);

  904. 

  905.                         CARLA_SAFE_ASSERT_BREAK(bigValueFilePathTry[0] != '\0');

  906.                         if (! plugin->isEnabled()) break;

  907. 

  908.                         String bigValueFilePath(bigValueFilePathTry);

  909. 

  910. #ifdef CARLA_OS_WIN

  911.                         // check if running under Wine

  912.                         if (bigValueFilePath.startsWith("/"))

  913.                             bigValueFilePath = bigValueFilePath.replaceSection(0, 1, "Z:\\").replace("/", "\\");

  914. #endif

  915. 

  916.                         File bigValueFile(bigValueFilePath);

  917.                         CARLA_SAFE_ASSERT_BREAK(bigValueFile.existsAsFile());

  918. 

  919.                         plugin->setCustomData(typeStr, keyStr, bigValueFile.loadFileAsString().toRawUTF8(), true);

  920. 

  921.                         bigValueFile.deleteFile();

  922.                     }

  923.                     else

  924.                     {

  925.                         char valueStr[valueSize+1];

  926.                         carla_zeroChars(valueStr, valueSize+1);

  927.                         fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  928. 

  929.                         if (plugin->isEnabled())

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

  931.                     }

  932.                 }

  933.                 else

  934.                 {

  935.                     if (plugin->isEnabled())

  936.                         plugin->setCustomData(typeStr, keyStr, "", true);

  937.                 }

  938. 

  939.                 break;

  940.             }

  941. 

  942.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  944.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  945. 

  946.                 char chunkFilePathTry[size+1];

  947.                 carla_zeroChars(chunkFilePathTry, size+1);

  948.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  949. 

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

  951.                 if (! plugin->isEnabled()) break;

  952. 

  953.                 String chunkFilePath(chunkFilePathTry);

  954. 

  955. #ifdef CARLA_OS_WIN

  956.                 // check if running under Wine

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

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

  959. #endif

  960. 

  961.                 File chunkFile(chunkFilePath);

  962.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  963. 

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

  965.                 chunkFile.deleteFile();

  966.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  967. 

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

  969. 

  970. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  972. #else

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

  974. #endif

  975.                 break;

  976.             }

  977. 

  978.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  981. 

  982.                 if (plugin->isEnabled())

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

  984.                 break;

  985.             }

  986. 

  987.             case kPluginBridgeNonRtClientSetOption: {

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

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

  990. 

  991.                 if (plugin->isEnabled())

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

  993.                 break;

  994.             }

  995. 

  996.             case kPluginBridgeNonRtClientSetOptions: {

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

  998. 

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

  1000.                 break;

  1001.             }

  1002. 

  1003.             case kPluginBridgeNonRtClientSetWindowTitle: {

  1004.                 const uint32_t size = fShmNonRtClientControl.readUInt();

  1005.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  1006. 

  1007.                 char title[size+1];

  1008.                 carla_zeroChars(title, size+1);

  1009.                 fShmNonRtClientControl.readCustomData(title, size);

  1010. 

  1011.                 plugin->setCustomUITitle(title);

  1012.                 break;

  1013.             }

  1014. 

  1015.             case kPluginBridgeNonRtClientGetParameterText: {

  1016.                 const int32_t index = fShmNonRtClientControl.readInt();

  1017. 

  1018.                 if (index >= 0 && plugin->isEnabled())

  1019.                 {

  1020.                     char bufStr[STR_MAX+1];

  1021.                     carla_zeroChars(bufStr, STR_MAX+1);

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

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

  1024. 

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

  1026. 

  1027.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1028. 

  1029.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1030. 

  1031.                     fShmNonRtServerControl.writeInt(index);

  1032.                     fShmNonRtServerControl.writeUInt(bufStrLen);

  1033.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);

  1034.                     fShmNonRtServerControl.commitWrite();

  1035. 

  1036.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1037.                 }

  1038.                 else

  1039.                 {

  1040.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1041. 

  1042.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);

  1043.                     fShmNonRtServerControl.writeInt(index);

  1044.                     fShmNonRtServerControl.writeUInt(0);

  1045.                     fShmNonRtServerControl.commitWrite();

  1046.                 }

  1047. 

  1048.                 break;

  1049.             }

  1050. 

  1051.             case kPluginBridgeNonRtClientPrepareForSave: {

  1052.                 if (! plugin->isEnabled())

  1053.                 {

  1054.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1055.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1056.                     fShmNonRtServerControl.commitWrite();

  1057.                     return;

  1058.                 }

  1059. 

  1060.                 plugin->prepareForSave(false);

  1061. 

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

  1063.                 {

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

  1065. 

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

  1067.                         continue;

  1068. 

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

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

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

  1072. 

  1073.                     if (valueLen > 16384)

  1074.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1075. 

  1076.                     {

  1077.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1078. 

  1079.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1080. 

  1081.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1083. 

  1084.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1086. 

  1087.                         fShmNonRtServerControl.writeUInt(valueLen);

  1088. 

  1089.                         if (valueLen > 0)

  1090.                         {

  1091.                             if (valueLen > 16384)

  1092.                             {

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

  1094. 

  1095.                                 filePath += CARLA_OS_SEP_STR ".CarlaCustomData_";

  1096.                                 filePath += fShmAudioPool.getFilenameSuffix();

  1097. 

  1098.                                 if (File(filePath).replaceWithText(cdata.value))

  1099.                                 {

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

  1101. 

  1102.                                     fShmNonRtServerControl.writeUInt(ulength);

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

  1104.                                 }

  1105.                                 else

  1106.                                 {

  1107.                                     fShmNonRtServerControl.writeUInt(0);

  1108.                                 }

  1109.                             }

  1110.                             else

  1111.                             {

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

  1113.                             }

  1114.                         }

  1115. 

  1116.                         fShmNonRtServerControl.commitWrite();

  1117.                     }

  1118. 

  1119.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1120.                 }

  1121. 

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

  1123.                 {

  1124.                     void* data = nullptr;

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

  1126.                     {

  1127.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1128. 

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

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

  1131. 

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

  1133. 

  1134.                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";

  1135.                         filePath += fShmAudioPool.getFilenameSuffix();

  1136. 

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

  1138.                         {

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

  1140. 

  1141.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1142. 

  1143.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1144.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1146.                             fShmNonRtServerControl.commitWrite();

  1147.                         }

  1148.                     }

  1149.                 }

  1150. 

  1151.                 {

  1152.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1153. 

  1154.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1155.                     fShmNonRtServerControl.commitWrite();

  1156.                 }

  1157.                 break;

  1158.             }

  1159. 

  1160.             case kPluginBridgeNonRtClientRestoreLV2State:

  1161.                 if (plugin->isEnabled())

  1162.                     plugin->restoreLV2State(false);

  1163.                 break;

  1164. 

  1165.             case kPluginBridgeNonRtClientShowUI:

  1166.                 if (plugin->isEnabled())

  1167.                     plugin->showCustomUI(true);

  1168.                 break;

  1169. 

  1170.             case kPluginBridgeNonRtClientHideUI:

  1171.                 if (plugin->isEnabled())

  1172.                     plugin->showCustomUI(false);

  1173.                 break;

  1174. 

  1175.             case kPluginBridgeNonRtClientEmbedUI: {

  1176.                 const uint64_t winId = fShmNonRtClientControl.readULong();

  1177.                 uint64_t resp = 0;

  1178. 

  1179.                 if (plugin->isEnabled())

  1180.                     resp = reinterpret_cast<uint64_t>(plugin->embedCustomUI(reinterpret_cast<void*>(winId)));

  1181. 

  1182.                 if (resp == 0)

  1183.                     resp = 1;

  1184. 

  1185.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1186. 

  1187.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerRespEmbedUI);

  1188.                 fShmNonRtServerControl.writeULong(reinterpret_cast<uint64_t>(resp));

  1189.                 fShmNonRtServerControl.commitWrite();

  1190.                 break;

  1191.             }

  1192. 

  1193.             case kPluginBridgeNonRtClientUiParameterChange: {

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

  1195.                 const float    value = fShmNonRtClientControl.readFloat();

  1196. 

  1197.                 if (plugin->isEnabled())

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

  1199.                 break;

  1200.             }

  1201. 

  1202.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1204. 

  1205.                 if (plugin->isEnabled())

  1206.                     plugin->uiProgramChange(index);

  1207.                 break;

  1208.             }

  1209. 

  1210.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1212. 

  1213.                 if (plugin->isEnabled())

  1214.                     plugin->uiMidiProgramChange(index);

  1215.                 break;

  1216.             }

  1217. 

  1218.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1222. 

  1223.                 if (plugin->isEnabled())

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

  1225.                 break;

  1226.             }

  1227. 

  1228.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1231. 

  1232.                 if (plugin->isEnabled())

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

  1234.                 break;

  1235.             }

  1236. 

  1237.             case kPluginBridgeNonRtClientQuit:

  1238.                 fClosingDown = true;

  1239.                 signalThreadShouldExit();

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

  1241.                 break;

  1242.             }

  1243.         }

  1244.     }

  1245. 

  1246.     // -------------------------------------------------------------------

  1247. 

  1248. protected:

  1249.     void run() override

  1250.     {

  1251. #ifdef __SSE2_MATH__

  1252.         // Set FTZ and DAZ flags

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

  1254. #endif

  1255. 

  1256.         bool quitReceived = false;

  1257. 

  1258.         for (; ! shouldThreadExit();)

  1259.         {

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

  1261. 

  1262.             if (! helper.ok)

  1263.                 continue;

  1264. 

  1265.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1266.             {

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

  1268.                 const CarlaPluginPtr plugin = pData->plugins[0].plugin;

  1269. 

  1270. #ifdef DEBUG

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

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

  1273.                 }

  1274. #endif

  1275. 

  1276.                 switch (opcode)

  1277.                 {

  1278.                 case kPluginBridgeRtClientNull:

  1279.                     break;

  1280. 

  1281.                 case kPluginBridgeRtClientSetAudioPool: {

  1282.                     if (fShmAudioPool.data != nullptr)

  1283.                     {

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

  1285.                         fShmAudioPool.data = nullptr;

  1286.                     }

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

  1288.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1290.                     break;

  1291.                 }

  1292. 

  1293.                 case kPluginBridgeRtClientSetBufferSize: {

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

  1295.                     pData->bufferSize = bufferSize;

  1296.                     bufferSizeChanged(bufferSize);

  1297.                     break;

  1298.                 }

  1299. 

  1300.                 case kPluginBridgeRtClientSetSampleRate: {

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

  1302.                     pData->sampleRate = sampleRate;

  1303.                     sampleRateChanged(sampleRate);

  1304.                     break;

  1305.                 }

  1306. 

  1307.                 case kPluginBridgeRtClientSetOnline:

  1308.                     fIsOffline = fShmRtClientControl.readBool();

  1309.                     offlineModeChanged(fIsOffline);

  1310.                     break;

  1311. 

  1312.                 // NOTE this is never used

  1313.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1318. 

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

  1320.                     {

  1321.                         event->type                 = kEngineEventTypeControl;

  1322.                         event->time                 = time;

  1323.                         event->channel              = channel;

  1324.                         event->ctrl.type            = kEngineControlEventTypeParameter;

  1325.                         event->ctrl.param           = param;

  1326.                         event->ctrl.midiValue       = -1;

  1327.                         event->ctrl.normalizedValue = value;

  1328.                         event->ctrl.handled         = true;

  1329.                     }

  1330.                     break;

  1331.                 }

  1332. 

  1333.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1337. 

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

  1339.                     {

  1340.                         event->type                 = kEngineEventTypeControl;

  1341.                         event->time                 = time;

  1342.                         event->channel              = channel;

  1343.                         event->ctrl.type            = kEngineControlEventTypeMidiBank;

  1344.                         event->ctrl.param           = index;

  1345.                         event->ctrl.midiValue       = -1;

  1346.                         event->ctrl.normalizedValue = 0.0f;

  1347.                         event->ctrl.handled         = true;

  1348.                     }

  1349.                     break;

  1350.                 }

  1351. 

  1352.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1356. 

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

  1358.                     {

  1359.                         event->type                 = kEngineEventTypeControl;

  1360.                         event->time                 = time;

  1361.                         event->channel              = channel;

  1362.                         event->ctrl.type            = kEngineControlEventTypeMidiProgram;

  1363.                         event->ctrl.param           = index;

  1364.                         event->ctrl.midiValue       = -1;

  1365.                         event->ctrl.normalizedValue = 0.0f;

  1366.                         event->ctrl.handled         = true;

  1367.                     }

  1368.                     break;

  1369.                 }

  1370. 

  1371.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1374. 

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

  1376.                     {

  1377.                         event->type                 = kEngineEventTypeControl;

  1378.                         event->time                 = time;

  1379.                         event->channel              = channel;

  1380.                         event->ctrl.type            = kEngineControlEventTypeAllSoundOff;

  1381.                         event->ctrl.param           = 0;

  1382.                         event->ctrl.midiValue       = -1;

  1383.                         event->ctrl.normalizedValue = 0.0f;

  1384.                         event->ctrl.handled         = true;

  1385.                     }

  1386.                 }   break;

  1387. 

  1388.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1391. 

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

  1393.                     {

  1394.                         event->type                 = kEngineEventTypeControl;

  1395.                         event->time                 = time;

  1396.                         event->channel              = channel;

  1397.                         event->ctrl.type            = kEngineControlEventTypeAllNotesOff;

  1398.                         event->ctrl.param           = 0;

  1399.                         event->ctrl.midiValue       = -1;

  1400.                         event->ctrl.normalizedValue = 0.0f;

  1401.                         event->ctrl.handled         = true;

  1402.                     }

  1403.                 }   break;

  1404. 

  1405.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1409.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1410. 

  1411.                     // FIXME variable-size stack

  1412.                     uint8_t data[size];

  1413. 

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

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

  1416. 

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

  1418.                     {

  1419.                         event->type    = kEngineEventTypeMidi;

  1420.                         event->time    = time;

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

  1422. 

  1423.                         event->midi.port = port;

  1424.                         event->midi.size = size;

  1425. 

  1426.                         if (size > EngineMidiEvent::kDataSize)

  1427.                         {

  1428.                             event->midi.dataExt = data;

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

  1430.                         }

  1431.                         else

  1432.                         {

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

  1434. 

  1435.                             uint8_t i=1;

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

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

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

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

  1440. 

  1441.                             event->midi.dataExt = nullptr;

  1442.                         }

  1443.                     }

  1444.                     break;

  1445.                 }

  1446. 

  1447.                 case kPluginBridgeRtClientProcess: {

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

  1449. 

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

  1451. 

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

  1453.                     {

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

  1455. 

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

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

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

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

  1460. 

  1461.                         const float* audioIn[audioInCount];

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

  1463.                         const float* cvIn[cvInCount];

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

  1465. 

  1466.                         float* fdata = fShmAudioPool.data;

  1467. 

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

  1469.                             audioIn[i] = fdata;

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

  1471.                             audioOut[i] = fdata;

  1472. 

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

  1474.                             cvIn[i] = fdata;

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

  1476.                             cvOut[i] = fdata;

  1477. 

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

  1479. 

  1480.                         timeInfo.playing   = bridgeTimeInfo.playing;

  1481.                         timeInfo.frame     = bridgeTimeInfo.frame;

  1482.                         timeInfo.usecs     = bridgeTimeInfo.usecs;

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

  1484. 

  1485.                         if (timeInfo.bbt.valid)

  1486.                         {

  1487.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1488.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1489.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1490. 

  1491.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1492.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1493. 

  1494.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1495.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1496.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1497.                         }

  1498. 

  1499.                         plugin->initBuffers();

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

  1501.                         plugin->unlock();

  1502.                     }

  1503. 

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

  1505.                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1506.                     std::size_t curMidiDataPos = 0;

  1507. 

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

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

  1510. 

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

  1512.                     {

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

  1514.                         {

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

  1516. 

  1517.                             if (event.type == kEngineEventTypeNull)

  1518.                                 break;

  1519. 

  1520.                             if (event.type == kEngineEventTypeControl)

  1521.                             {

  1522.                                 uint8_t data[3];

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

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

  1525. 

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

  1527.                                     break;

  1528. 

  1529.                                 // set time

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

  1531.                                 midiData = midiData + 4;

  1532.                                 curMidiDataPos += 4;

  1533. 

  1534.                                 // set port

  1535.                                 *midiData++ = 0;

  1536.                                 ++curMidiDataPos;

  1537. 

  1538.                                 // set size

  1539.                                 *midiData++ = size;

  1540.                                 ++curMidiDataPos;

  1541. 

  1542.                                 // set data

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

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

  1545. 

  1546.                                 curMidiDataPos += size;

  1547.                             }

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

  1549.                             {

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

  1551. 

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

  1553.                                     break;

  1554. 

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

  1556. 

  1557.                                 // set time

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

  1559.                                 midiData += 4;

  1560.                                 curMidiDataPos += 4;

  1561. 

  1562.                                 // set port

  1563.                                 *midiData++ = _midiEvent.port;

  1564.                                 ++curMidiDataPos;

  1565. 

  1566.                                 // set size

  1567.                                 *midiData++ = _midiEvent.size;

  1568.                                 ++curMidiDataPos;

  1569. 

  1570.                                 // set data

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

  1572. 

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

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

  1575. 

  1576.                                 curMidiDataPos += _midiEvent.size;

  1577.                             }

  1578.                         }

  1579. 

  1580.                         if (curMidiDataPos != 0 &&

  1581.                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)

  1582.                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);

  1583. 

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

  1585.                     }

  1586. 

  1587.                 }   break;

  1588. 

  1589.                 case kPluginBridgeRtClientQuit: {

  1590.                     quitReceived = true;

  1591.                     fClosingDown = true;

  1592.                     signalThreadShouldExit();

  1593.                 }   break;

  1594.                 }

  1595.             }

  1596.         }

  1597. 

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

  1599. 

  1600.         if (! quitReceived)

  1601.         {

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

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

  1604. 

  1605.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1606.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1607.             fShmNonRtServerControl.writeUInt(messageSize);

  1608.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1609.             fShmNonRtServerControl.commitWrite();

  1610.         }

  1611.     }

  1612. 

  1613.     // called from process thread above

  1614.     EngineEvent* getNextFreeInputEvent() const noexcept

  1615.     {

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

  1617.         {

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

  1619. 

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

  1621.                 return event;

  1622.         }

  1623.         return nullptr;

  1624.     }

  1625. 

  1626.     void latencyChanged(const uint32_t samples) noexcept override

  1627.     {

  1628.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1629. 

  1630.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);

  1631.         fShmNonRtServerControl.writeUInt(samples);

  1632.         fShmNonRtServerControl.commitWrite();

  1633.     }

  1634. 

  1635.     // -------------------------------------------------------------------

  1636. 

  1637. private:

  1638.     BridgeAudioPool          fShmAudioPool;

  1639.     BridgeRtClientControl    fShmRtClientControl;

  1640.     BridgeNonRtClientControl fShmNonRtClientControl;

  1641.     BridgeNonRtServerControl fShmNonRtServerControl;

  1642. 

  1643.     CarlaString fBaseNameAudioPool;

  1644.     CarlaString fBaseNameRtClientControl;

  1645.     CarlaString fBaseNameNonRtClientControl;

  1646.     CarlaString fBaseNameNonRtServerControl;

  1647. 

  1648.     bool fClosingDown;

  1649.     bool fIsOffline;

  1650.     bool fFirstIdle;

  1651.     int64_t fLastPingTime;

  1652. 

  1653.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1654. };

  1655. 

  1656. // -----------------------------------------------------------------------

  1657. 

  1658. namespace EngineInit {

  1659. 

  1660. CarlaEngine* newBridge(const char* const audioPoolBaseName,

  1661.                        const char* const rtClientBaseName,

  1662.                        const char* const nonRtClientBaseName,

  1663.                        const char* const nonRtServerBaseName)

  1664. {

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

  1666. }

  1667. 

  1668. }

  1669. 

  1670. // -----------------------------------------------------------------------

  1671. 

  1672. CARLA_BACKEND_END_NAMESPACE

  1673. 

  1674. // -----------------------------------------------------------------------

  1675. 

  1676. #include "CarlaBridgeUtils.cpp"

  1677. 

  1678. // -----------------------------------------------------------------------