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

1581 lines
59KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 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. #include "jackbridge/JackBridge.hpp"

  31. 

  32. using juce::File;

  33. using juce::MemoryBlock;

  34. using juce::String;

  35. using juce::Time;

  36. 

  37. template<typename T>

  38. bool jackbridge_shm_map2(char* shm, T*& value) noexcept

  39. {

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

  41.     return (value != nullptr);

  42. }

  43. 

  44. CARLA_BACKEND_START_NAMESPACE

  45. 

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

  47. 

  48. struct BridgeAudioPool {

  49.     CarlaString filename;

  50.     float* data;

  51.     char shm[64];

  52. 

  53.     BridgeAudioPool() noexcept

  54.         : filename(),

  55.           data(nullptr)

  56.     {

  57.         carla_zeroChars(shm, 64);

  58.         jackbridge_shm_init(shm);

  59.     }

  60. 

  61.     ~BridgeAudioPool() noexcept

  62.     {

  63.         // should be cleared by now

  64.         CARLA_SAFE_ASSERT(data == nullptr);

  65. 

  66.         clear();

  67.     }

  68. 

  69.     void clear() noexcept

  70.     {

  71.         filename.clear();

  72. 

  73.         if (! jackbridge_shm_is_valid(shm))

  74.         {

  75.             CARLA_SAFE_ASSERT(data == nullptr);

  76.             return;

  77.         }

  78. 

  79.         data = nullptr;

  80. 

  81.         jackbridge_shm_close(shm);

  82.         jackbridge_shm_init(shm);

  83.     }

  84. 

  85.     bool attach() noexcept

  86.     {

  87.         // must be invalid right now

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

  89. 

  90.         jackbridge_shm_attach(shm, filename);

  91. 

  92.         return jackbridge_shm_is_valid(shm);

  93.     }

  94. 

  95.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeAudioPool)

  96. };

  97. 

  98. // -------------------------------------------------------------------

  99. 

  100. struct BridgeRtClientControl : public CarlaRingBufferControl<SmallStackBuffer> {

  101.     CarlaString filename;

  102.     BridgeRtClientData* data;

  103.     char shm[64];

  104. 

  105.     BridgeRtClientControl() noexcept

  106.         : filename(),

  107.           data(nullptr)

  108.     {

  109.         carla_zeroChars(shm, 64);

  110.         jackbridge_shm_init(shm);

  111.     }

  112. 

  113.     ~BridgeRtClientControl() noexcept override

  114.     {

  115.         // should be cleared by now

  116.         CARLA_SAFE_ASSERT(data == nullptr);

  117. 

  118.         clear();

  119.     }

  120. 

  121.     void clear() noexcept

  122.     {

  123.         filename.clear();

  124. 

  125.         if (data != nullptr)

  126.             unmapData();

  127. 

  128.         if (! jackbridge_shm_is_valid(shm))

  129.             return;

  130. 

  131.         jackbridge_shm_close(shm);

  132.         jackbridge_shm_init(shm);

  133.     }

  134. 

  135.     bool attach() noexcept

  136.     {

  137.         // must be invalid right now

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

  139. 

  140.         jackbridge_shm_attach(shm, filename);

  141. 

  142.         return jackbridge_shm_is_valid(shm);

  143.     }

  144. 

  145.     bool mapData() noexcept

  146.     {

  147.         CARLA_SAFE_ASSERT(data == nullptr);

  148. 

  149.         if (jackbridge_shm_map2<BridgeRtClientData>(shm, data))

  150.         {

  151.             CARLA_SAFE_ASSERT(data->midiOut[0] == 0);

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

  153.             return true;

  154.         }

  155. 

  156.         return false;

  157.     }

  158. 

  159.     void unmapData() noexcept

  160.     {

  161.         data = nullptr;

  162.         setRingBuffer(nullptr, false);

  163.     }

  164. 

  165.     bool postClient() noexcept

  166.     {

  167.         CARLA_SAFE_ASSERT_RETURN(data != nullptr, false);

  168. 

  169.         return jackbridge_sem_post(&data->sem.client);

  170.     }

  171. 

  172.     bool waitForServer(const uint secs, bool* const timedOut) noexcept

  173.     {

  174.         CARLA_SAFE_ASSERT_RETURN(data != nullptr, false);

  175. 

  176.         return jackbridge_sem_timedwait(&data->sem.server, secs, timedOut);

  177.     }

  178. 

  179.     PluginBridgeRtClientOpcode readOpcode() noexcept

  180.     {

  181.         return static_cast<PluginBridgeRtClientOpcode>(readUInt());

  182.     }

  183. 

  184.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeRtClientControl)

  185. };

  186. 

  187. // -------------------------------------------------------------------

  188. 

  189. struct BridgeNonRtClientControl : public CarlaRingBufferControl<BigStackBuffer> {

  190.     CarlaString filename;

  191.     BridgeNonRtClientData* data;

  192.     char shm[64];

  193. 

  194.     BridgeNonRtClientControl() noexcept

  195.         : filename(),

  196.           data(nullptr)

  197.     {

  198.         carla_zeroChars(shm, 64);

  199.         jackbridge_shm_init(shm);

  200.     }

  201. 

  202.     ~BridgeNonRtClientControl() noexcept override

  203.     {

  204.         // should be cleared by now

  205.         CARLA_SAFE_ASSERT(data == nullptr);

  206. 

  207.         clear();

  208.     }

  209. 

  210.     void clear() noexcept

  211.     {

  212.         filename.clear();

  213. 

  214.         if (data != nullptr)

  215.             unmapData();

  216. 

  217.         if (! jackbridge_shm_is_valid(shm))

  218.         {

  219.             CARLA_SAFE_ASSERT(data == nullptr);

  220.             return;

  221.         }

  222. 

  223.         jackbridge_shm_close(shm);

  224.         jackbridge_shm_init(shm);

  225.     }

  226. 

  227.     bool attach() noexcept

  228.     {

  229.         // must be invalid right now

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

  231. 

  232.         jackbridge_shm_attach(shm, filename);

  233. 

  234.         return jackbridge_shm_is_valid(shm);

  235.     }

  236. 

  237.     bool mapData() noexcept

  238.     {

  239.         CARLA_SAFE_ASSERT(data == nullptr);

  240. 

  241.         if (jackbridge_shm_map2<BridgeNonRtClientData>(shm, data))

  242.         {

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

  244.             return true;

  245.         }

  246. 

  247.         return false;

  248.     }

  249. 

  250.     void unmapData() noexcept

  251.     {

  252.         data = nullptr;

  253.         setRingBuffer(nullptr, false);

  254.     }

  255. 

  256.     PluginBridgeNonRtClientOpcode readOpcode() noexcept

  257.     {

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

  259.     }

  260. 

  261.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtClientControl)

  262. };

  263. 

  264. // -------------------------------------------------------------------

  265. 

  266. struct BridgeNonRtServerControl : public CarlaRingBufferControl<HugeStackBuffer> {

  267.     CarlaMutex mutex;

  268.     CarlaString filename;

  269.     BridgeNonRtServerData* data;

  270.     char shm[64];

  271. 

  272.     BridgeNonRtServerControl() noexcept

  273.         :  mutex(),

  274.            filename(),

  275.            data(nullptr)

  276.     {

  277.         carla_zeroChars(shm, 64);

  278.         jackbridge_shm_init(shm);

  279.     }

  280. 

  281.     ~BridgeNonRtServerControl() noexcept override

  282.     {

  283.         // should be cleared by now

  284.         CARLA_SAFE_ASSERT(data == nullptr);

  285. 

  286.         clear();

  287.     }

  288. 

  289.     void clear() noexcept

  290.     {

  291.         filename.clear();

  292. 

  293.         if (data != nullptr)

  294.             unmapData();

  295. 

  296.         if (! jackbridge_shm_is_valid(shm))

  297.         {

  298.             CARLA_SAFE_ASSERT(data == nullptr);

  299.             return;

  300.         }

  301. 

  302.         jackbridge_shm_close(shm);

  303.         jackbridge_shm_init(shm);

  304.     }

  305. 

  306.     bool attach() noexcept

  307.     {

  308.         // must be invalid right now

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

  310. 

  311.         jackbridge_shm_attach(shm, filename);

  312. 

  313.         return jackbridge_shm_is_valid(shm);

  314.     }

  315. 

  316.     bool mapData() noexcept

  317.     {

  318.         CARLA_SAFE_ASSERT(data == nullptr);

  319. 

  320.         if (jackbridge_shm_map2<BridgeNonRtServerData>(shm, data))

  321.         {

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

  323.             return true;

  324.         }

  325. 

  326.         return false;

  327.     }

  328. 

  329.     void unmapData() noexcept

  330.     {

  331.         data = nullptr;

  332.         setRingBuffer(nullptr, false);

  333.     }

  334. 

  335.     void writeOpcode(const PluginBridgeNonRtServerOpcode opcode) noexcept

  336.     {

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

  338.     }

  339. 

  340.     void waitIfDataIsReachingLimit() noexcept

  341.     {

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

  343.             return;

  344. 

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

  346.         {

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

  348.             {

  349.                 //carla_stdout("Client waitIfDataIsReachingLimit() reached and waited successfully");

  350.                 writeOpcode(kPluginBridgeNonRtServerPong);

  351.                 commitWrite();

  352.                 return;

  353.             }

  354.             carla_msleep(20);

  355.         }

  356. 

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

  358.     }

  359. 

  360.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtServerControl)

  361. };

  362. 

  363. // -------------------------------------------------------------------

  364. 

  365. class CarlaEngineBridge : public CarlaEngine,

  366.                           public CarlaThread

  367. {

  368. public:

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

  370.         : CarlaEngine(),

  371.           CarlaThread("CarlaEngineBridge"),

  372.           fShmAudioPool(),

  373.           fShmRtClientControl(),

  374.           fShmNonRtClientControl(),

  375.           fShmNonRtServerControl(),

  376.           fIsOffline(false),

  377.           fFirstIdle(true),

  378.           fLastPingTime(-1),

  379.           leakDetector_CarlaEngineBridge()

  380.     {

  381.         carla_stdout("CarlaEngineBridge::CarlaEngineBridge(\"%s\", \"%s\", \"%s\", \"%s\")", audioPoolBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);

  382. 

  383.         fShmAudioPool.filename  = PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL;

  384.         fShmAudioPool.filename += audioPoolBaseName;

  385. 

  386.         fShmRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_RT_CLIENT;

  387.         fShmRtClientControl.filename += rtClientBaseName;

  388. 

  389.         fShmNonRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT;

  390.         fShmNonRtClientControl.filename += nonRtClientBaseName;

  391. 

  392.         fShmNonRtServerControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER;

  393.         fShmNonRtServerControl.filename += nonRtServerBaseName;

  394.     }

  395. 

  396.     ~CarlaEngineBridge() noexcept override

  397.     {

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

  399. 

  400.         clear();

  401.     }

  402. 

  403.     // -------------------------------------

  404.     // CarlaEngine virtual calls

  405. 

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

  407.     {

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

  409. 

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

  411.         {

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

  413.             return false;

  414.         }

  415. 

  416.         if (! fShmAudioPool.attach())

  417.         {

  418.             carla_stdout("Failed to attach to audio pool shared memory");

  419.             return false;

  420.         }

  421. 

  422.         if (! fShmRtClientControl.attach())

  423.         {

  424.             clear();

  425.             carla_stdout("Failed to attach to rt client control shared memory");

  426.             return false;

  427.         }

  428. 

  429.         if (! fShmRtClientControl.mapData())

  430.         {

  431.             clear();

  432.             carla_stdout("Failed to map rt client control shared memory");

  433.             return false;

  434.         }

  435. 

  436.         if (! fShmNonRtClientControl.attach())

  437.         {

  438.             clear();

  439.             carla_stdout("Failed to attach to non-rt client control shared memory");

  440.             return false;

  441.         }

  442. 

  443.         if (! fShmNonRtClientControl.mapData())

  444.         {

  445.             clear();

  446.             carla_stdout("Failed to map non-rt control client shared memory");

  447.             return false;

  448.         }

  449. 

  450.         if (! fShmNonRtServerControl.attach())

  451.         {

  452.             clear();

  453.             carla_stdout("Failed to attach to non-rt server control shared memory");

  454.             return false;

  455.         }

  456. 

  457.         if (! fShmNonRtServerControl.mapData())

  458.         {

  459.             clear();

  460.             carla_stdout("Failed to map non-rt control server shared memory");

  461.             return false;

  462.         }

  463. 

  464.         PluginBridgeNonRtClientOpcode opcode;

  465. 

  466.         opcode = fShmNonRtClientControl.readOpcode();

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

  468. 

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

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

  471. 

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

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

  474. 

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

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

  477. 

  478.         opcode = fShmNonRtClientControl.readOpcode();

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

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

  481. 

  482.         opcode = fShmNonRtClientControl.readOpcode();

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

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

  485. 

  486.         carla_stdout("Carla Client Info:");

  487.         carla_stdout("  BufferSize: %i", pData->bufferSize);

  488.         carla_stdout("  SampleRate: %g", pData->sampleRate);

  489.         carla_stdout("  sizeof(BridgeRtClientData):    %i/" P_SIZE, shmRtClientDataSize,    sizeof(BridgeRtClientData));

  490.         carla_stdout("  sizeof(BridgeNonRtClientData): %i/" P_SIZE, shmNonRtClientDataSize, sizeof(BridgeNonRtClientData));

  491.         carla_stdout("  sizeof(BridgeNonRtServerData): %i/" P_SIZE, shmNonRtServerDataSize, sizeof(BridgeNonRtServerData));

  492. 

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

  494.             return false;

  495. 

  496.         // tell backend we're live

  497.         {

  498.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  499. 

  500.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  501.             fShmNonRtServerControl.commitWrite();

  502.         }

  503. 

  504.         startThread();

  505. 

  506.         return true;

  507.     }

  508. 

  509.     bool close() override

  510.     {

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

  512.         fLastPingTime = -1;

  513. 

  514.         CarlaEngine::close();

  515. 

  516.         stopThread(5000);

  517.         clear();

  518. 

  519.         return true;

  520.     }

  521. 

  522.     bool isRunning() const noexcept override

  523.     {

  524.         return isThreadRunning() || ! fFirstIdle;

  525.     }

  526. 

  527.     bool isOffline() const noexcept override

  528.     {

  529.         return fIsOffline;

  530.     }

  531. 

  532.     EngineType getType() const noexcept override

  533.     {

  534.         return kEngineTypeBridge;

  535.     }

  536. 

  537.     const char* getCurrentDriverName() const noexcept

  538.     {

  539.         return "Bridge";

  540.     }

  541. 

  542.     void idle() noexcept override

  543.     {

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

  545.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  546. 

  547.         const bool wasFirstIdle(fFirstIdle);

  548. 

  549.         if (fFirstIdle)

  550.         {

  551.             fFirstIdle = false;

  552.             fLastPingTime = Time::currentTimeMillis();

  553.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  554. 

  555.             char bufStr[STR_MAX+1];

  556.             uint32_t bufStrSize;

  557. 

  558.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  559. 

  560.             // kPluginBridgeNonRtServerPluginInfo1

  561.             {

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

  563.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  569.                 fShmNonRtServerControl.commitWrite();

  570.             }

  571. 

  572.             // kPluginBridgeNonRtServerPluginInfo2

  573.             {

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

  575.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  576. 

  577.                 carla_zeroChars(bufStr, STR_MAX);

  578.                 plugin->getRealName(bufStr);

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

  580.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  581.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  582. 

  583.                 carla_zeroChars(bufStr, STR_MAX);

  584.                 plugin->getLabel(bufStr);

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

  586.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  587.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  588. 

  589.                 carla_zeroChars(bufStr, STR_MAX);

  590.                 plugin->getMaker(bufStr);

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

  592.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  593.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  594. 

  595.                 carla_zeroChars(bufStr, STR_MAX);

  596.                 plugin->getCopyright(bufStr);

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

  598.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  599.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  600. 

  601.                 fShmNonRtServerControl.commitWrite();

  602.             }

  603. 

  604.             // kPluginBridgeNonRtServerAudioCount

  605.             {

  606.                 // uint/ins, uint/outs

  607.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  608.                 fShmNonRtServerControl.writeUInt(plugin->getAudioInCount());

  609.                 fShmNonRtServerControl.writeUInt(plugin->getAudioOutCount());

  610.                 fShmNonRtServerControl.commitWrite();

  611.             }

  612. 

  613.             // kPluginBridgeNonRtServerMidiCount

  614.             {

  615.                 // uint/ins, uint/outs

  616.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  619.                 fShmNonRtServerControl.commitWrite();

  620.             }

  621. 

  622.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  623. 

  624.             // kPluginBridgeNonRtServerParameter*

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

  626.             {

  627.                 // uint/count

  628.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  629.                 fShmNonRtServerControl.writeUInt(count);

  630.                 fShmNonRtServerControl.commitWrite();

  631. 

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

  633.                 {

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

  635. 

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

  637.                         continue;

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

  639.                         continue;

  640. 

  641.                     // kPluginBridgeNonRtServerParameterData1

  642.                     {

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

  644.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  645.                         fShmNonRtServerControl.writeUInt(i);

  646.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  647.                         fShmNonRtServerControl.writeUInt(paramData.type);

  648.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  649.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  650.                         fShmNonRtServerControl.commitWrite();

  651.                     }

  652. 

  653.                     // kPluginBridgeNonRtServerParameterData2

  654.                     {

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

  656.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  657.                         fShmNonRtServerControl.writeUInt(i);

  658. 

  659.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  662.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  663.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  664. 

  665.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  668.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  669.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  670. 

  671.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  674.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  675.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  676. 

  677.                         fShmNonRtServerControl.commitWrite();

  678.                     }

  679. 

  680.                     // kPluginBridgeNonRtServerParameterRanges

  681.                     {

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

  683. 

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

  685.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  686.                         fShmNonRtServerControl.writeUInt(i);

  687.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  688.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  689.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  690.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  691.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  692.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  693.                         fShmNonRtServerControl.commitWrite();

  694.                     }

  695. 

  696.                     // kPluginBridgeNonRtServerParameterValue2

  697.                     {

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

  699.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  700.                         fShmNonRtServerControl.writeUInt(i);

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

  702.                         fShmNonRtServerControl.commitWrite();

  703.                     }

  704. 

  705.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  706.                 }

  707.             }

  708. 

  709.             // kPluginBridgeNonRtServerProgram*

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

  711.             {

  712.                 // uint/count

  713.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  714.                 fShmNonRtServerControl.writeUInt(count);

  715.                 fShmNonRtServerControl.commitWrite();

  716. 

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

  718.                 {

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

  720.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  721.                     fShmNonRtServerControl.writeUInt(i);

  722. 

  723.                     carla_zeroChars(bufStr, STR_MAX);

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

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

  726.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  727.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  728. 

  729.                     fShmNonRtServerControl.commitWrite();

  730.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  731.                 }

  732.             }

  733. 

  734.             // kPluginBridgeNonRtServerMidiProgram*

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

  736.             {

  737.                 // uint/count

  738.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  739.                 fShmNonRtServerControl.writeUInt(count);

  740.                 fShmNonRtServerControl.commitWrite();

  741. 

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

  743.                 {

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

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

  746. 

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

  748.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  749.                     fShmNonRtServerControl.writeUInt(i);

  750.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  751.                     fShmNonRtServerControl.writeUInt(mpData.program);

  752. 

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

  754.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  756. 

  757.                     fShmNonRtServerControl.commitWrite();

  758.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  759.                 }

  760.             }

  761. 

  762.             // ready!

  763.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  764.             fShmNonRtServerControl.commitWrite();

  765.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  766. 

  767.             carla_stdout("Carla Client Ready!");

  768.             fLastPingTime = Time::currentTimeMillis();

  769.         }

  770. 

  771.         // send parameter outputs

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

  773.         {

  774.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  775. 

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

  777.             {

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

  779.                     continue;

  780. 

  781.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  782.                 fShmNonRtServerControl.writeUInt(i);

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

  784. 

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

  786.                 if (! fShmNonRtServerControl.commitWrite())

  787.                     break;

  788.             }

  789.         }

  790. 

  791.         CarlaEngine::idle();

  792. 

  793.         try {

  794.             handleNonRtData();

  795.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  796. 

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

  798.         {

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

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

  801.         }

  802.     }

  803. 

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

  805.     {

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

  807. 

  808.         if (fLastPingTime < 0)

  809.             return;

  810. 

  811.         switch (action)

  812.         {

  813.         // uint/index float/value

  814.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  815.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  816.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  817.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  819.             fShmNonRtServerControl.writeFloat(value3);

  820.             fShmNonRtServerControl.commitWrite();

  821.         }   break;

  822. 

  823.         // uint/index float/value

  824.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  825.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  826.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  827.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  829.             fShmNonRtServerControl.writeFloat(value3);

  830.             fShmNonRtServerControl.commitWrite();

  831.         }   break;

  832. 

  833.         // int/index

  834.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  835.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  836.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  837.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  838.             fShmNonRtServerControl.writeInt(value1);

  839.             fShmNonRtServerControl.commitWrite();

  840.         }   break;

  841. 

  842.         // int/index

  843.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  844.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  845.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  846.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  847.             fShmNonRtServerControl.writeInt(value1);

  848.             fShmNonRtServerControl.commitWrite();

  849.         }   break;

  850. 

  851.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  852.             if (value1 != 1)

  853.             {

  854.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  855.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  856.                 fShmNonRtServerControl.commitWrite();

  857.             }

  858.             break;

  859. 

  860.         default:

  861.             break;

  862.         }

  863.     }

  864. 

  865.     // -------------------------------------------------------------------

  866. 

  867.     void clear() noexcept

  868.     {

  869.         fShmAudioPool.clear();

  870.         fShmRtClientControl.clear();

  871.         fShmNonRtClientControl.clear();

  872.         fShmNonRtServerControl.clear();

  873.     }

  874. 

  875.     void handleNonRtData()

  876.     {

  877.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  878.         {

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

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

  881. 

  882. #ifdef DEBUG

  883.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  885.             }

  886. #endif

  887. 

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

  889.                 fLastPingTime = Time::currentTimeMillis();

  890. 

  891.             switch (opcode)

  892.             {

  893.             case kPluginBridgeNonRtClientNull:

  894.                 break;

  895. 

  896.             case kPluginBridgeNonRtClientPing: {

  897.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  898. 

  899.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  900.                 fShmNonRtServerControl.commitWrite();

  901.             }   break;

  902. 

  903.             case kPluginBridgeNonRtClientPingOnOff: {

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

  905. 

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

  907. 

  908.                 carla_stdout("Carla bridge client side, OnOff ping checks => %s", bool2str(onOff));

  909.             }   break;

  910. 

  911.             case kPluginBridgeNonRtClientActivate:

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

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

  914.                 break;

  915. 

  916.             case kPluginBridgeNonRtClientDeactivate:

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

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

  919.                 break;

  920. 

  921.             case kPluginBridgeNonRtClientSetBufferSize: {

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

  923.                 pData->bufferSize = bufferSize;

  924.                 bufferSizeChanged(bufferSize);

  925.                 break;

  926.             }

  927. 

  928.             case kPluginBridgeNonRtClientSetSampleRate: {

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

  930.                 pData->sampleRate = sampleRate;

  931.                 sampleRateChanged(sampleRate);

  932.                 break;

  933.             }

  934. 

  935.             case kPluginBridgeNonRtClientSetOffline:

  936.                 fIsOffline = true;

  937.                 offlineModeChanged(true);

  938.                 break;

  939. 

  940.             case kPluginBridgeNonRtClientSetOnline:

  941.                 fIsOffline = false;

  942.                 offlineModeChanged(false);

  943.                 break;

  944. 

  945.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  948. 

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

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

  951.                 break;

  952.             }

  953. 

  954.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  957. 

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

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

  960.                 break;

  961.             }

  962. 

  963.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  966. 

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

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

  969.                 break;

  970.             }

  971. 

  972.             case kPluginBridgeNonRtClientSetProgram: {

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

  974. 

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

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

  977.                 break;

  978.             }

  979. 

  980.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  982. 

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

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

  985.                 break;

  986.             }

  987. 

  988.             case kPluginBridgeNonRtClientSetCustomData: {

  989.                 // type

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

  991.                 char typeStr[typeSize+1];

  992.                 carla_zeroChars(typeStr, typeSize+1);

  993.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  994. 

  995.                 // key

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

  997.                 char keyStr[keySize+1];

  998.                 carla_zeroChars(keyStr, keySize+1);

  999.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  1000. 

  1001.                 // value

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

  1003.                 char valueStr[valueSize+1];

  1004.                 carla_zeroChars(valueStr, valueSize+1);

  1005.                 fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  1006. 

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

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

  1009.                 break;

  1010.             }

  1011. 

  1012.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  1014.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  1015. 

  1016.                 char chunkFilePathTry[size+1];

  1017.                 carla_zeroChars(chunkFilePathTry, size+1);

  1018.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  1019. 

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

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

  1022. 

  1023.                 carla_stdout("Carla bridge client side setChunkData 001");

  1024. 

  1025.                 String chunkFilePath(chunkFilePathTry);

  1026. 

  1027. #ifdef CARLA_OS_WIN

  1028.                 // check if running under Wine

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

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

  1031. #endif

  1032. 

  1033.                 File chunkFile(chunkFilePath);

  1034.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  1035. 

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

  1037.                 chunkFile.deleteFile();

  1038.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  1039. 

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

  1041.                 carla_stdout("Carla bridge client side setChunkData 002");

  1042. 

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

  1044.                 carla_stdout("Carla bridge client side setChunkData done");

  1045.                 break;

  1046.             }

  1047. 

  1048.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  1051. 

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

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

  1054.                 break;

  1055.             }

  1056. 

  1057.             case kPluginBridgeNonRtClientSetOption: {

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

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

  1060. 

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

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

  1063.                 break;

  1064.             }

  1065. 

  1066.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1068. 

  1069.                 plugin->prepareForSave();

  1070. 

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

  1072.                 {

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

  1074. 

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

  1076.                         continue;

  1077. 

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

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

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

  1081. 

  1082.                     {

  1083.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1084. 

  1085.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1086. 

  1087.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1089. 

  1090.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1092. 

  1093.                         fShmNonRtServerControl.writeUInt(valueLen);

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

  1095. 

  1096.                         fShmNonRtServerControl.commitWrite();

  1097.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1098.                     }

  1099.                 }

  1100. 

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

  1102.                 {

  1103.                     void* data = nullptr;

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

  1105.                     {

  1106.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1107. 

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

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

  1110. 

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

  1112. 

  1113.                         filePath += CARLA_OS_SEP_STR;

  1114.                         filePath += ".CarlaChunk_";

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

  1116. 

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

  1118.                         {

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

  1120. 

  1121.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1122. 

  1123.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1124.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1126.                             fShmNonRtServerControl.commitWrite();

  1127.                         }

  1128.                     }

  1129.                 }

  1130. 

  1131.                 {

  1132.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1133. 

  1134.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1135.                     fShmNonRtServerControl.commitWrite();

  1136.                 }

  1137.                 break;

  1138.             }

  1139. 

  1140.             case kPluginBridgeNonRtClientShowUI:

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

  1142.                     plugin->showCustomUI(true);

  1143.                 break;

  1144. 

  1145.             case kPluginBridgeNonRtClientHideUI:

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

  1147.                     plugin->showCustomUI(false);

  1148.                 break;

  1149. 

  1150.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1153. 

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

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

  1156.                 break;

  1157.             }

  1158. 

  1159.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1161. 

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

  1163.                     plugin->uiProgramChange(index);

  1164.                 break;

  1165.             }

  1166. 

  1167.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1169. 

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

  1171.                     plugin->uiMidiProgramChange(index);

  1172.                 break;

  1173.             }

  1174. 

  1175.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1179. 

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

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

  1182.                 break;

  1183.             }

  1184. 

  1185.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1188. 

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

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

  1191.                 break;

  1192.             }

  1193. 

  1194.             case kPluginBridgeNonRtClientQuit:

  1195.                 signalThreadShouldExit();

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

  1197.                 break;

  1198.             }

  1199.         }

  1200.     }

  1201. 

  1202.     // -------------------------------------------------------------------

  1203. 

  1204. protected:

  1205.     void run() override

  1206.     {

  1207.         bool timedOut, quitReceived = false;

  1208. 

  1209.         for (; ! shouldThreadExit();)

  1210.         {

  1211.             if (! fShmRtClientControl.waitForServer(5, &timedOut))

  1212.             {

  1213.                 /*

  1214.                 * As a special case we ignore timeouts for plugin bridges.

  1215.                 * Some big Windows plugins (Kontakt, FL Studio VST) can time out when initializing or doing UI stuff.

  1216.                 * If any other error happens the plugin bridge is stopped.

  1217.                 */

  1218.                 if (timedOut) continue;

  1219. 

  1220.                 carla_stderr2("Bridge timed-out, final post...");

  1221.                 fShmRtClientControl.postClient();

  1222.                 carla_stderr2("Bridge timed-out, done.");

  1223.                 signalThreadShouldExit();

  1224.                 break;

  1225.             }

  1226. 

  1227.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1228.             {

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

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

  1231. 

  1232. #ifdef DEBUG

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

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

  1235.                 }

  1236. #endif

  1237. 

  1238.                 switch (opcode)

  1239.                 {

  1240.                 case kPluginBridgeRtClientNull:

  1241.                     break;

  1242. 

  1243.                 case kPluginBridgeRtClientSetAudioPool: {

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

  1245.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1247.                     break;

  1248.                 }

  1249. 

  1250.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1255. 

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

  1257.                     {

  1258.                         event->type    = kEngineEventTypeControl;

  1259.                         event->time    = time;

  1260.                         event->channel = channel;

  1261.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1262.                         event->ctrl.param = param;

  1263.                         event->ctrl.value = value;

  1264.                     }

  1265.                     break;

  1266.                 }

  1267. 

  1268.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1272. 

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

  1274.                     {

  1275.                         event->type    = kEngineEventTypeControl;

  1276.                         event->time    = time;

  1277.                         event->channel = channel;

  1278.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1279.                         event->ctrl.param = index;

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

  1281.                     }

  1282.                     break;

  1283.                 }

  1284. 

  1285.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1289. 

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

  1291.                     {

  1292.                         event->type    = kEngineEventTypeControl;

  1293.                         event->time    = time;

  1294.                         event->channel = channel;

  1295.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1296.                         event->ctrl.param = index;

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

  1298.                     }

  1299.                     break;

  1300.                 }

  1301. 

  1302.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1305. 

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

  1307.                     {

  1308.                         event->type    = kEngineEventTypeControl;

  1309.                         event->time    = time;

  1310.                         event->channel = channel;

  1311.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1312.                         event->ctrl.param = 0;

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

  1314.                     }

  1315.                 }   break;

  1316. 

  1317.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1320. 

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

  1322.                     {

  1323.                         event->type    = kEngineEventTypeControl;

  1324.                         event->time    = time;

  1325.                         event->channel = channel;

  1326.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1327.                         event->ctrl.param = 0;

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

  1329.                     }

  1330.                 }   break;

  1331. 

  1332.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1336.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1337. 

  1338.                     uint8_t data[size];

  1339. 

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

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

  1342. 

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

  1344.                     {

  1345.                         event->type    = kEngineEventTypeMidi;

  1346.                         event->time    = time;

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

  1348. 

  1349.                         event->midi.port = port;

  1350.                         event->midi.size = size;

  1351. 

  1352.                         if (size > EngineMidiEvent::kDataSize)

  1353.                         {

  1354.                             event->midi.dataExt = data;

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

  1356.                         }

  1357.                         else

  1358.                         {

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

  1360. 

  1361.                             uint8_t i=1;

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

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

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

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

  1366. 

  1367.                             event->midi.dataExt = nullptr;

  1368.                         }

  1369.                     }

  1370.                     break;

  1371.                 }

  1372. 

  1373.                 case kPluginBridgeRtClientProcess: {

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

  1375. 

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

  1377.                     {

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

  1379. 

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

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

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

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

  1384. 

  1385.                         const float* audioIn[audioInCount];

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

  1387.                         const float* cvIn[cvInCount];

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

  1389. 

  1390.                         float* fdata = fShmAudioPool.data;

  1391. 

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

  1393.                             audioIn[i] = fdata;

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

  1395.                             audioOut[i] = fdata;

  1396. 

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

  1398.                             cvIn[i] = fdata;

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

  1400.                             cvOut[i] = fdata;

  1401. 

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

  1403. 

  1404.                         timeInfo.playing = bridgeTimeInfo.playing;

  1405.                         timeInfo.frame   = bridgeTimeInfo.frame;

  1406.                         timeInfo.usecs   = bridgeTimeInfo.usecs;

  1407.                         timeInfo.valid   = bridgeTimeInfo.valid;

  1408. 

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

  1410.                         {

  1411.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1412.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1413.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1414. 

  1415.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1416.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1417. 

  1418.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1419.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1420.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1421.                         }

  1422. 

  1423.                         plugin->initBuffers();

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

  1425.                         plugin->unlock();

  1426.                     }

  1427. 

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

  1429.                     carla_zeroBytes(midiData, kBridgeRtClientDataMidiOutSize);

  1430.                     std::size_t curMidiDataPos = 0;

  1431. 

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

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

  1434. 

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

  1436.                     {

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

  1438.                         {

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

  1440. 

  1441.                             if (event.type == kEngineEventTypeNull)

  1442.                                 break;

  1443. 

  1444.                             if (event.type == kEngineEventTypeControl)

  1445.                             {

  1446.                                 uint8_t size;

  1447.                                 uint8_t data[3];

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

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

  1450. 

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

  1452.                                     break;

  1453. 

  1454.                                 // set size

  1455.                                 *midiData++ = size;

  1456. 

  1457.                                 // set time

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

  1459.                                 midiData = midiData + 4;

  1460. 

  1461.                                 // set data

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

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

  1464. 

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

  1466.                             }

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

  1468.                             {

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

  1470. 

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

  1472.                                     break;

  1473. 

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

  1475. 

  1476.                                 // set size

  1477.                                 *midiData++ = _midiEvent.size;

  1478. 

  1479.                                 // set time

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

  1481.                                 midiData = midiData + 4;

  1482. 

  1483.                                 // set data

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

  1485. 

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

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

  1488. 

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

  1490.                             }

  1491.                         }

  1492. 

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

  1494.                     }

  1495. 

  1496.                 }   break;

  1497. 

  1498.                 case kPluginBridgeRtClientQuit: {

  1499.                     quitReceived = true;

  1500.                     signalThreadShouldExit();

  1501.                 }   break;

  1502.                 }

  1503.             }

  1504. 

  1505.             if (! fShmRtClientControl.postClient())

  1506.                 carla_stderr2("Could not post to client rt semaphore");

  1507.         }

  1508. 

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

  1510. 

  1511.         if (! quitReceived)

  1512.         {

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

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

  1515. 

  1516.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1517.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1518.             fShmNonRtServerControl.writeUInt(messageSize);

  1519.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1520.             fShmNonRtServerControl.commitWrite();

  1521.         }

  1522.     }

  1523. 

  1524.     // called from process thread above

  1525.     EngineEvent* getNextFreeInputEvent() const noexcept

  1526.     {

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

  1528.         {

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

  1530. 

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

  1532.                 return event;

  1533.         }

  1534.         return nullptr;

  1535.     }

  1536. 

  1537.     // -------------------------------------------------------------------

  1538. 

  1539. private:

  1540.     BridgeAudioPool          fShmAudioPool;

  1541.     BridgeRtClientControl    fShmRtClientControl;

  1542.     BridgeNonRtClientControl fShmNonRtClientControl;

  1543.     BridgeNonRtServerControl fShmNonRtServerControl;

  1544. 

  1545.     bool fIsOffline;

  1546.     bool fFirstIdle;

  1547.     int64_t fLastPingTime;

  1548. 

  1549.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1550. };

  1551. 

  1552. // -----------------------------------------------------------------------

  1553. 

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

  1555. {

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

  1557. }

  1558. 

  1559. // -----------------------------------------------------------------------

  1560. 

  1561. #ifdef BRIDGE_PLUGIN

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

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

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

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

  1566. #endif

  1567. 

  1568. CARLA_BACKEND_END_NAMESPACE

  1569. 

  1570. // -----------------------------------------------------------------------

  1571. 

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

  1573. extern "C" __declspec (dllexport)

  1574. #else

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

  1576. #endif

  1577. void carla_register_native_plugin_carla();

  1578. void carla_register_native_plugin_carla(){}

  1579. 

  1580. // -----------------------------------------------------------------------