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

1572 lines
58KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2015 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. using juce::Thread;

  37. 

  38. template<typename T>

  39. bool jackbridge_shm_map2(void* shm, T*& value) noexcept

  40. {

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

  42.     return (value != nullptr);

  43. }

  44. 

  45. CARLA_BACKEND_START_NAMESPACE

  46. 

  47. // -------------------------------------------------------------------

  48. 

  49. struct BridgeAudioPool {

  50.     CarlaString filename;

  51.     float* data;

  52.     char shm[64];

  53. 

  54.     BridgeAudioPool() noexcept

  55.         : filename(),

  56.           data(nullptr)

  57.     {

  58.         carla_zeroChars(shm, 64);

  59.         jackbridge_shm_init(shm);

  60.     }

  61. 

  62.     ~BridgeAudioPool() noexcept

  63.     {

  64.         // should be cleared by now

  65.         CARLA_SAFE_ASSERT(data == nullptr);

  66. 

  67.         clear();

  68.     }

  69. 

  70.     void clear() noexcept

  71.     {

  72.         filename.clear();

  73. 

  74.         if (! jackbridge_shm_is_valid(shm))

  75.         {

  76.             CARLA_SAFE_ASSERT(data == nullptr);

  77.             return;

  78.         }

  79. 

  80.         data = nullptr;

  81. 

  82.         jackbridge_shm_close(shm);

  83.         jackbridge_shm_init(shm);

  84.     }

  85. 

  86.     bool attach() noexcept

  87.     {

  88.         // must be invalid right now

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

  90. 

  91.         jackbridge_shm_attach(shm, filename);

  92. 

  93.         return jackbridge_shm_is_valid(shm);

  94.     }

  95. 

  96.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeAudioPool)

  97. };

  98. 

  99. // -------------------------------------------------------------------

  100. 

  101. struct BridgeRtClientControl : public CarlaRingBufferControl<SmallStackBuffer> {

  102.     CarlaString filename;

  103.     BridgeRtClientData* data;

  104.     char shm[64];

  105. 

  106.     BridgeRtClientControl() noexcept

  107.         : filename(),

  108.           data(nullptr)

  109.     {

  110.         carla_zeroChars(shm, 64);

  111.         jackbridge_shm_init(shm);

  112.     }

  113. 

  114.     ~BridgeRtClientControl() noexcept override

  115.     {

  116.         // should be cleared by now

  117.         CARLA_SAFE_ASSERT(data == nullptr);

  118. 

  119.         clear();

  120.     }

  121. 

  122.     void clear() noexcept

  123.     {

  124.         filename.clear();

  125. 

  126.         if (data != nullptr)

  127.             unmapData();

  128. 

  129.         if (! jackbridge_shm_is_valid(shm))

  130.             return;

  131. 

  132.         jackbridge_shm_close(shm);

  133.         jackbridge_shm_init(shm);

  134.     }

  135. 

  136.     bool attach() noexcept

  137.     {

  138.         // must be invalid right now

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

  140. 

  141.         jackbridge_shm_attach(shm, filename);

  142. 

  143.         return jackbridge_shm_is_valid(shm);

  144.     }

  145. 

  146.     bool mapData() noexcept

  147.     {

  148.         CARLA_SAFE_ASSERT(data == nullptr);

  149. 

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

  151.         {

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

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

  154.             return true;

  155.         }

  156. 

  157.         return false;

  158.     }

  159. 

  160.     void unmapData() noexcept

  161.     {

  162.         data = nullptr;

  163.         setRingBuffer(nullptr, false);

  164.     }

  165. 

  166.     PluginBridgeRtClientOpcode readOpcode() noexcept

  167.     {

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

  169.     }

  170. 

  171.     // helper class that automatically posts semaphore on destructor

  172.     struct WaitHelper {

  173.         BridgeRtClientData* const data;

  174.         const bool ok;

  175. 

  176.         WaitHelper(BridgeRtClientControl& c) noexcept

  177.             : data(c.data),

  178.               ok(jackbridge_sem_timedwait(&data->sem.server, 5000)) {}

  179. 

  180.         ~WaitHelper() noexcept

  181.         {

  182.             if (ok)

  183.                 jackbridge_sem_post(&data->sem.client);

  184.         }

  185. 

  186.         CARLA_DECLARE_NON_COPY_STRUCT(WaitHelper)

  187.     };

  188. 

  189.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeRtClientControl)

  190. };

  191. 

  192. // -------------------------------------------------------------------

  193. 

  194. struct BridgeNonRtClientControl : public CarlaRingBufferControl<BigStackBuffer> {

  195.     CarlaString filename;

  196.     BridgeNonRtClientData* data;

  197.     char shm[64];

  198. 

  199.     BridgeNonRtClientControl() noexcept

  200.         : filename(),

  201.           data(nullptr)

  202.     {

  203.         carla_zeroChars(shm, 64);

  204.         jackbridge_shm_init(shm);

  205.     }

  206. 

  207.     ~BridgeNonRtClientControl() noexcept override

  208.     {

  209.         // should be cleared by now

  210.         CARLA_SAFE_ASSERT(data == nullptr);

  211. 

  212.         clear();

  213.     }

  214. 

  215.     void clear() noexcept

  216.     {

  217.         filename.clear();

  218. 

  219.         if (data != nullptr)

  220.             unmapData();

  221. 

  222.         if (! jackbridge_shm_is_valid(shm))

  223.         {

  224.             CARLA_SAFE_ASSERT(data == nullptr);

  225.             return;

  226.         }

  227. 

  228.         jackbridge_shm_close(shm);

  229.         jackbridge_shm_init(shm);

  230.     }

  231. 

  232.     bool attach() noexcept

  233.     {

  234.         // must be invalid right now

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

  236. 

  237.         jackbridge_shm_attach(shm, filename);

  238. 

  239.         return jackbridge_shm_is_valid(shm);

  240.     }

  241. 

  242.     bool mapData() noexcept

  243.     {

  244.         CARLA_SAFE_ASSERT(data == nullptr);

  245. 

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

  247.         {

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

  249.             return true;

  250.         }

  251. 

  252.         return false;

  253.     }

  254. 

  255.     void unmapData() noexcept

  256.     {

  257.         data = nullptr;

  258.         setRingBuffer(nullptr, false);

  259.     }

  260. 

  261.     PluginBridgeNonRtClientOpcode readOpcode() noexcept

  262.     {

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

  264.     }

  265. 

  266.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtClientControl)

  267. };

  268. 

  269. // -------------------------------------------------------------------

  270. 

  271. struct BridgeNonRtServerControl : public CarlaRingBufferControl<HugeStackBuffer> {

  272.     CarlaMutex mutex;

  273.     CarlaString filename;

  274.     BridgeNonRtServerData* data;

  275.     char shm[64];

  276. 

  277.     BridgeNonRtServerControl() noexcept

  278.         :  mutex(),

  279.            filename(),

  280.            data(nullptr)

  281.     {

  282.         carla_zeroChars(shm, 64);

  283.         jackbridge_shm_init(shm);

  284.     }

  285. 

  286.     ~BridgeNonRtServerControl() noexcept override

  287.     {

  288.         // should be cleared by now

  289.         CARLA_SAFE_ASSERT(data == nullptr);

  290. 

  291.         clear();

  292.     }

  293. 

  294.     void clear() noexcept

  295.     {

  296.         filename.clear();

  297. 

  298.         if (data != nullptr)

  299.             unmapData();

  300. 

  301.         if (! jackbridge_shm_is_valid(shm))

  302.         {

  303.             CARLA_SAFE_ASSERT(data == nullptr);

  304.             return;

  305.         }

  306. 

  307.         jackbridge_shm_close(shm);

  308.         jackbridge_shm_init(shm);

  309.     }

  310. 

  311.     bool attach() noexcept

  312.     {

  313.         // must be invalid right now

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

  315. 

  316.         jackbridge_shm_attach(shm, filename);

  317. 

  318.         return jackbridge_shm_is_valid(shm);

  319.     }

  320. 

  321.     bool mapData() noexcept

  322.     {

  323.         CARLA_SAFE_ASSERT(data == nullptr);

  324. 

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

  326.         {

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

  328.             return true;

  329.         }

  330. 

  331.         return false;

  332.     }

  333. 

  334.     void unmapData() noexcept

  335.     {

  336.         data = nullptr;

  337.         setRingBuffer(nullptr, false);

  338.     }

  339. 

  340.     void writeOpcode(const PluginBridgeNonRtServerOpcode opcode) noexcept

  341.     {

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

  343.     }

  344. 

  345.     void waitIfDataIsReachingLimit() noexcept

  346.     {

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

  348.             return;

  349. 

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

  351.         {

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

  353.             {

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

  355.                 writeOpcode(kPluginBridgeNonRtServerPong);

  356.                 commitWrite();

  357.                 return;

  358.             }

  359.             carla_msleep(20);

  360.         }

  361. 

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

  363.     }

  364. 

  365.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtServerControl)

  366. };

  367. 

  368. // -------------------------------------------------------------------

  369. 

  370. class CarlaEngineBridge : public CarlaEngine,

  371.                           public Thread

  372. {

  373. public:

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

  375.         : CarlaEngine(),

  376.           Thread("CarlaEngineBridge"),

  377.           fShmAudioPool(),

  378.           fShmRtClientControl(),

  379.           fShmNonRtClientControl(),

  380.           fShmNonRtServerControl(),

  381.           fIsOffline(false),

  382.           fFirstIdle(true),

  383.           fLastPingTime(-1)

  384.     {

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

  386. 

  387.         fShmAudioPool.filename  = PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL;

  388.         fShmAudioPool.filename += audioPoolBaseName;

  389. 

  390.         fShmRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_RT_CLIENT;

  391.         fShmRtClientControl.filename += rtClientBaseName;

  392. 

  393.         fShmNonRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT;

  394.         fShmNonRtClientControl.filename += nonRtClientBaseName;

  395. 

  396.         fShmNonRtServerControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER;

  397.         fShmNonRtServerControl.filename += nonRtServerBaseName;

  398.     }

  399. 

  400.     ~CarlaEngineBridge() noexcept override

  401.     {

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

  403. 

  404.         clear();

  405.     }

  406. 

  407.     // -------------------------------------

  408.     // CarlaEngine virtual calls

  409. 

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

  411.     {

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

  413. 

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

  415.         {

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

  417.             return false;

  418.         }

  419. 

  420.         if (! fShmAudioPool.attach())

  421.         {

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

  423.             return false;

  424.         }

  425. 

  426.         if (! fShmRtClientControl.attach())

  427.         {

  428.             clear();

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

  430.             return false;

  431.         }

  432. 

  433.         if (! fShmRtClientControl.mapData())

  434.         {

  435.             clear();

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

  437.             return false;

  438.         }

  439. 

  440.         if (! fShmNonRtClientControl.attach())

  441.         {

  442.             clear();

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

  444.             return false;

  445.         }

  446. 

  447.         if (! fShmNonRtClientControl.mapData())

  448.         {

  449.             clear();

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

  451.             return false;

  452.         }

  453. 

  454.         if (! fShmNonRtServerControl.attach())

  455.         {

  456.             clear();

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

  458.             return false;

  459.         }

  460. 

  461.         if (! fShmNonRtServerControl.mapData())

  462.         {

  463.             clear();

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

  465.             return false;

  466.         }

  467. 

  468.         PluginBridgeNonRtClientOpcode opcode;

  469. 

  470.         opcode = fShmNonRtClientControl.readOpcode();

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

  472. 

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

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

  475. 

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

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

  478. 

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

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

  481. 

  482.         opcode = fShmNonRtClientControl.readOpcode();

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

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

  485. 

  486.         opcode = fShmNonRtClientControl.readOpcode();

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

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

  489. 

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

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

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

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

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

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

  496. 

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

  498.             return false;

  499. 

  500.         // tell backend we're live

  501.         {

  502.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  503. 

  504.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  505.             fShmNonRtServerControl.commitWrite();

  506.         }

  507. 

  508.         startThread(10);

  509. 

  510.         return true;

  511.     }

  512. 

  513.     bool close() override

  514.     {

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

  516.         fLastPingTime = -1;

  517. 

  518.         CarlaEngine::close();

  519. 

  520.         stopThread(5000);

  521.         clear();

  522. 

  523.         return true;

  524.     }

  525. 

  526.     bool isRunning() const noexcept override

  527.     {

  528.         return isThreadRunning() || ! fFirstIdle;

  529.     }

  530. 

  531.     bool isOffline() const noexcept override

  532.     {

  533.         return fIsOffline;

  534.     }

  535. 

  536.     EngineType getType() const noexcept override

  537.     {

  538.         return kEngineTypeBridge;

  539.     }

  540. 

  541.     const char* getCurrentDriverName() const noexcept

  542.     {

  543.         return "Bridge";

  544.     }

  545. 

  546.     void idle() noexcept override

  547.     {

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

  549.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  550. 

  551.         const bool wasFirstIdle(fFirstIdle);

  552. 

  553.         if (fFirstIdle)

  554.         {

  555.             fFirstIdle = false;

  556.             fLastPingTime = Time::currentTimeMillis();

  557.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  558. 

  559.             char bufStr[STR_MAX+1];

  560.             uint32_t bufStrSize;

  561. 

  562.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  563. 

  564.             // kPluginBridgeNonRtServerPluginInfo1

  565.             {

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

  567.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  573.                 fShmNonRtServerControl.commitWrite();

  574.             }

  575. 

  576.             // kPluginBridgeNonRtServerPluginInfo2

  577.             {

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

  579.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  580. 

  581.                 carla_zeroChars(bufStr, STR_MAX);

  582.                 plugin->getRealName(bufStr);

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

  584.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  585.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  586. 

  587.                 carla_zeroChars(bufStr, STR_MAX);

  588.                 plugin->getLabel(bufStr);

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

  590.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  591.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  592. 

  593.                 carla_zeroChars(bufStr, STR_MAX);

  594.                 plugin->getMaker(bufStr);

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

  596.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  597.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  598. 

  599.                 carla_zeroChars(bufStr, STR_MAX);

  600.                 plugin->getCopyright(bufStr);

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

  602.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  603.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  604. 

  605.                 fShmNonRtServerControl.commitWrite();

  606.             }

  607. 

  608.             // kPluginBridgeNonRtServerAudioCount

  609.             {

  610.                 // uint/ins, uint/outs

  611.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

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

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

  614.                 fShmNonRtServerControl.commitWrite();

  615.             }

  616. 

  617.             // kPluginBridgeNonRtServerMidiCount

  618.             {

  619.                 // uint/ins, uint/outs

  620.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  623.                 fShmNonRtServerControl.commitWrite();

  624.             }

  625. 

  626.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  627. 

  628.             // kPluginBridgeNonRtServerParameter*

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

  630.             {

  631.                 // uint/count

  632.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  633.                 fShmNonRtServerControl.writeUInt(count);

  634.                 fShmNonRtServerControl.commitWrite();

  635. 

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

  637.                 {

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

  639. 

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

  641.                         continue;

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

  643.                         continue;

  644. 

  645.                     // kPluginBridgeNonRtServerParameterData1

  646.                     {

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

  648.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  649.                         fShmNonRtServerControl.writeUInt(i);

  650.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  651.                         fShmNonRtServerControl.writeUInt(paramData.type);

  652.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  653.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  654.                         fShmNonRtServerControl.commitWrite();

  655.                     }

  656. 

  657.                     // kPluginBridgeNonRtServerParameterData2

  658.                     {

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

  660.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  661.                         fShmNonRtServerControl.writeUInt(i);

  662. 

  663.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  666.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  667.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  668. 

  669.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  672.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  673.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  674. 

  675.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  678.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  679.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  680. 

  681.                         fShmNonRtServerControl.commitWrite();

  682.                     }

  683. 

  684.                     // kPluginBridgeNonRtServerParameterRanges

  685.                     {

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

  687. 

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

  689.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  690.                         fShmNonRtServerControl.writeUInt(i);

  691.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  692.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  693.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  694.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  695.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  696.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  697.                         fShmNonRtServerControl.commitWrite();

  698.                     }

  699. 

  700.                     // kPluginBridgeNonRtServerParameterValue2

  701.                     {

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

  703.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  704.                         fShmNonRtServerControl.writeUInt(i);

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

  706.                         fShmNonRtServerControl.commitWrite();

  707.                     }

  708. 

  709.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  710.                 }

  711.             }

  712. 

  713.             // kPluginBridgeNonRtServerProgram*

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

  715.             {

  716.                 // uint/count

  717.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  718.                 fShmNonRtServerControl.writeUInt(count);

  719.                 fShmNonRtServerControl.commitWrite();

  720. 

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

  722.                 {

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

  724.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  725.                     fShmNonRtServerControl.writeUInt(i);

  726. 

  727.                     carla_zeroChars(bufStr, STR_MAX);

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

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

  730.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  731.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  732. 

  733.                     fShmNonRtServerControl.commitWrite();

  734.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  735.                 }

  736.             }

  737. 

  738.             // kPluginBridgeNonRtServerMidiProgram*

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

  740.             {

  741.                 // uint/count

  742.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  743.                 fShmNonRtServerControl.writeUInt(count);

  744.                 fShmNonRtServerControl.commitWrite();

  745. 

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

  747.                 {

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

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

  750. 

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

  752.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  753.                     fShmNonRtServerControl.writeUInt(i);

  754.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  755.                     fShmNonRtServerControl.writeUInt(mpData.program);

  756. 

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

  758.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  760. 

  761.                     fShmNonRtServerControl.commitWrite();

  762.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  763.                 }

  764.             }

  765. 

  766.             // ready!

  767.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  768.             fShmNonRtServerControl.commitWrite();

  769.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  770. 

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

  772.             fLastPingTime = Time::currentTimeMillis();

  773.         }

  774. 

  775.         // send parameter outputs

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

  777.         {

  778.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  779. 

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

  781.             {

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

  783.                     continue;

  784. 

  785.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  786.                 fShmNonRtServerControl.writeUInt(i);

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

  788. 

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

  790.                 if (! fShmNonRtServerControl.commitWrite())

  791.                     break;

  792.             }

  793.         }

  794. 

  795.         CarlaEngine::idle();

  796. 

  797.         try {

  798.             handleNonRtData();

  799.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  800. 

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

  802.         {

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

  804.             threadShouldExit();

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

  806.         }

  807.     }

  808. 

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

  810.     {

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

  812. 

  813.         if (fLastPingTime < 0)

  814.             return;

  815. 

  816.         switch (action)

  817.         {

  818.         // uint/index float/value

  819.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  820.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  821.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  822.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  824.             fShmNonRtServerControl.writeFloat(value3);

  825.             fShmNonRtServerControl.commitWrite();

  826.         }   break;

  827. 

  828.         // uint/index float/value

  829.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  830.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  831.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  832.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  834.             fShmNonRtServerControl.writeFloat(value3);

  835.             fShmNonRtServerControl.commitWrite();

  836.         }   break;

  837. 

  838.         // int/index

  839.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  840.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  841.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  842.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  843.             fShmNonRtServerControl.writeInt(value1);

  844.             fShmNonRtServerControl.commitWrite();

  845.         }   break;

  846. 

  847.         // int/index

  848.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  849.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  850.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  851.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  852.             fShmNonRtServerControl.writeInt(value1);

  853.             fShmNonRtServerControl.commitWrite();

  854.         }   break;

  855. 

  856.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  857.             if (value1 != 1)

  858.             {

  859.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  860.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  861.                 fShmNonRtServerControl.commitWrite();

  862.             }

  863.             break;

  864. 

  865.         default:

  866.             break;

  867.         }

  868.     }

  869. 

  870.     // -------------------------------------------------------------------

  871. 

  872.     void clear() noexcept

  873.     {

  874.         fShmAudioPool.clear();

  875.         fShmRtClientControl.clear();

  876.         fShmNonRtClientControl.clear();

  877.         fShmNonRtServerControl.clear();

  878.     }

  879. 

  880.     void handleNonRtData()

  881.     {

  882.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  883.         {

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

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

  886. 

  887. #ifdef DEBUG

  888.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  890.             }

  891. #endif

  892. 

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

  894.                 fLastPingTime = Time::currentTimeMillis();

  895. 

  896.             switch (opcode)

  897.             {

  898.             case kPluginBridgeNonRtClientNull:

  899.                 break;

  900. 

  901.             case kPluginBridgeNonRtClientPing: {

  902.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  903. 

  904.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  905.                 fShmNonRtServerControl.commitWrite();

  906.             }   break;

  907. 

  908.             case kPluginBridgeNonRtClientPingOnOff: {

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

  910. 

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

  912. 

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

  914.             }   break;

  915. 

  916.             case kPluginBridgeNonRtClientActivate:

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

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

  919.                 break;

  920. 

  921.             case kPluginBridgeNonRtClientDeactivate:

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

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

  924.                 break;

  925. 

  926.             case kPluginBridgeNonRtClientSetBufferSize: {

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

  928.                 pData->bufferSize = bufferSize;

  929.                 bufferSizeChanged(bufferSize);

  930.                 break;

  931.             }

  932. 

  933.             case kPluginBridgeNonRtClientSetSampleRate: {

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

  935.                 pData->sampleRate = sampleRate;

  936.                 sampleRateChanged(sampleRate);

  937.                 break;

  938.             }

  939. 

  940.             case kPluginBridgeNonRtClientSetOffline:

  941.                 fIsOffline = true;

  942.                 offlineModeChanged(true);

  943.                 break;

  944. 

  945.             case kPluginBridgeNonRtClientSetOnline:

  946.                 fIsOffline = false;

  947.                 offlineModeChanged(false);

  948.                 break;

  949. 

  950.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  953. 

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

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

  956.                 break;

  957.             }

  958. 

  959.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  962. 

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

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

  965.                 break;

  966.             }

  967. 

  968.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  971. 

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

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

  974.                 break;

  975.             }

  976. 

  977.             case kPluginBridgeNonRtClientSetProgram: {

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

  979. 

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

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

  982.                 break;

  983.             }

  984. 

  985.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  987. 

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

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

  990.                 break;

  991.             }

  992. 

  993.             case kPluginBridgeNonRtClientSetCustomData: {

  994.                 // type

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

  996.                 char typeStr[typeSize+1];

  997.                 carla_zeroChars(typeStr, typeSize+1);

  998.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  999. 

  1000.                 // key

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

  1002.                 char keyStr[keySize+1];

  1003.                 carla_zeroChars(keyStr, keySize+1);

  1004.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  1005. 

  1006.                 // value

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

  1008.                 char valueStr[valueSize+1];

  1009.                 carla_zeroChars(valueStr, valueSize+1);

  1010.                 fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  1011. 

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

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

  1014.                 break;

  1015.             }

  1016. 

  1017.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  1019.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  1020. 

  1021.                 char chunkFilePathTry[size+1];

  1022.                 carla_zeroChars(chunkFilePathTry, size+1);

  1023.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  1024. 

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

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

  1027. 

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

  1029. 

  1030.                 String chunkFilePath(chunkFilePathTry);

  1031. 

  1032. #ifdef CARLA_OS_WIN

  1033.                 // check if running under Wine

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

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

  1036. #endif

  1037. 

  1038.                 File chunkFile(chunkFilePath);

  1039.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  1040. 

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

  1042.                 chunkFile.deleteFile();

  1043.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  1044. 

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

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

  1047. 

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

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

  1050.                 break;

  1051.             }

  1052. 

  1053.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  1056. 

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

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

  1059.                 break;

  1060.             }

  1061. 

  1062.             case kPluginBridgeNonRtClientSetOption: {

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

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

  1065. 

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

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

  1068.                 break;

  1069.             }

  1070. 

  1071.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1073. 

  1074.                 plugin->prepareForSave();

  1075. 

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

  1077.                 {

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

  1079. 

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

  1081.                         continue;

  1082. 

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

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

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

  1086. 

  1087.                     {

  1088.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1089. 

  1090.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1091. 

  1092.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1094. 

  1095.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1097. 

  1098.                         fShmNonRtServerControl.writeUInt(valueLen);

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

  1100. 

  1101.                         fShmNonRtServerControl.commitWrite();

  1102.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1103.                     }

  1104.                 }

  1105. 

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

  1107.                 {

  1108.                     void* data = nullptr;

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

  1110.                     {

  1111.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1112. 

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

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

  1115. 

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

  1117. 

  1118.                         filePath += CARLA_OS_SEP_STR;

  1119.                         filePath += ".CarlaChunk_";

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

  1121. 

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

  1123.                         {

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

  1125. 

  1126.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1127. 

  1128.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1129.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1131.                             fShmNonRtServerControl.commitWrite();

  1132.                         }

  1133.                     }

  1134.                 }

  1135. 

  1136.                 {

  1137.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1138. 

  1139.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1140.                     fShmNonRtServerControl.commitWrite();

  1141.                 }

  1142.                 break;

  1143.             }

  1144. 

  1145.             case kPluginBridgeNonRtClientShowUI:

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

  1147.                     plugin->showCustomUI(true);

  1148.                 break;

  1149. 

  1150.             case kPluginBridgeNonRtClientHideUI:

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

  1152.                     plugin->showCustomUI(false);

  1153.                 break;

  1154. 

  1155.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1158. 

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

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

  1161.                 break;

  1162.             }

  1163. 

  1164.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1166. 

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

  1168.                     plugin->uiProgramChange(index);

  1169.                 break;

  1170.             }

  1171. 

  1172.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1174. 

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

  1176.                     plugin->uiMidiProgramChange(index);

  1177.                 break;

  1178.             }

  1179. 

  1180.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1184. 

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

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

  1187.                 break;

  1188.             }

  1189. 

  1190.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1193. 

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

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

  1196.                 break;

  1197.             }

  1198. 

  1199.             case kPluginBridgeNonRtClientQuit:

  1200.                 signalThreadShouldExit();

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

  1202.                 break;

  1203.             }

  1204.         }

  1205.     }

  1206. 

  1207.     // -------------------------------------------------------------------

  1208. 

  1209. protected:

  1210.     void run() override

  1211.     {

  1212.         bool quitReceived = false;

  1213. 

  1214.         for (; ! threadShouldExit();)

  1215.         {

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

  1217. 

  1218.             if (! helper.ok)

  1219.                 continue;

  1220. 

  1221.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1222.             {

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

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

  1225. 

  1226. #ifdef DEBUG

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

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

  1229.                 }

  1230. #endif

  1231. 

  1232.                 switch (opcode)

  1233.                 {

  1234.                 case kPluginBridgeRtClientNull:

  1235.                     break;

  1236. 

  1237.                 case kPluginBridgeRtClientSetAudioPool: {

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

  1239.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1241.                     break;

  1242.                 }

  1243. 

  1244.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1249. 

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

  1251.                     {

  1252.                         event->type    = kEngineEventTypeControl;

  1253.                         event->time    = time;

  1254.                         event->channel = channel;

  1255.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1256.                         event->ctrl.param = param;

  1257.                         event->ctrl.value = value;

  1258.                     }

  1259.                     break;

  1260.                 }

  1261. 

  1262.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1266. 

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

  1268.                     {

  1269.                         event->type    = kEngineEventTypeControl;

  1270.                         event->time    = time;

  1271.                         event->channel = channel;

  1272.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1273.                         event->ctrl.param = index;

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

  1275.                     }

  1276.                     break;

  1277.                 }

  1278. 

  1279.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1283. 

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

  1285.                     {

  1286.                         event->type    = kEngineEventTypeControl;

  1287.                         event->time    = time;

  1288.                         event->channel = channel;

  1289.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1290.                         event->ctrl.param = index;

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

  1292.                     }

  1293.                     break;

  1294.                 }

  1295. 

  1296.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1299. 

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

  1301.                     {

  1302.                         event->type    = kEngineEventTypeControl;

  1303.                         event->time    = time;

  1304.                         event->channel = channel;

  1305.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1306.                         event->ctrl.param = 0;

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

  1308.                     }

  1309.                 }   break;

  1310. 

  1311.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1314. 

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

  1316.                     {

  1317.                         event->type    = kEngineEventTypeControl;

  1318.                         event->time    = time;

  1319.                         event->channel = channel;

  1320.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1321.                         event->ctrl.param = 0;

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

  1323.                     }

  1324.                 }   break;

  1325. 

  1326.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1330.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1331. 

  1332.                     uint8_t data[size];

  1333. 

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

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

  1336. 

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

  1338.                     {

  1339.                         event->type    = kEngineEventTypeMidi;

  1340.                         event->time    = time;

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

  1342. 

  1343.                         event->midi.port = port;

  1344.                         event->midi.size = size;

  1345. 

  1346.                         if (size > EngineMidiEvent::kDataSize)

  1347.                         {

  1348.                             event->midi.dataExt = data;

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

  1350.                         }

  1351.                         else

  1352.                         {

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

  1354. 

  1355.                             uint8_t i=1;

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

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

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

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

  1360. 

  1361.                             event->midi.dataExt = nullptr;

  1362.                         }

  1363.                     }

  1364.                     break;

  1365.                 }

  1366. 

  1367.                 case kPluginBridgeRtClientProcess: {

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

  1369. 

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

  1371.                     {

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

  1373. 

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

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

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

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

  1378. 

  1379.                         const float* audioIn[audioInCount];

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

  1381.                         const float* cvIn[cvInCount];

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

  1383. 

  1384.                         float* fdata = fShmAudioPool.data;

  1385. 

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

  1387.                             audioIn[i] = fdata;

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

  1389.                             audioOut[i] = fdata;

  1390. 

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

  1392.                             cvIn[i] = fdata;

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

  1394.                             cvOut[i] = fdata;

  1395. 

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

  1397. 

  1398.                         timeInfo.playing = bridgeTimeInfo.playing;

  1399.                         timeInfo.frame   = bridgeTimeInfo.frame;

  1400.                         timeInfo.usecs   = bridgeTimeInfo.usecs;

  1401.                         timeInfo.valid   = bridgeTimeInfo.valid;

  1402. 

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

  1404.                         {

  1405.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1406.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1407.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1408. 

  1409.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1410.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1411. 

  1412.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1413.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1414.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1415.                         }

  1416. 

  1417.                         plugin->initBuffers();

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

  1419.                         plugin->unlock();

  1420.                     }

  1421. 

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

  1423.                     carla_zeroBytes(midiData, kBridgeRtClientDataMidiOutSize);

  1424.                     std::size_t curMidiDataPos = 0;

  1425. 

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

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

  1428. 

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

  1430.                     {

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

  1432.                         {

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

  1434. 

  1435.                             if (event.type == kEngineEventTypeNull)

  1436.                                 break;

  1437. 

  1438.                             if (event.type == kEngineEventTypeControl)

  1439.                             {

  1440.                                 uint8_t size;

  1441.                                 uint8_t data[3];

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

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

  1444. 

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

  1446.                                     break;

  1447. 

  1448.                                 // set size

  1449.                                 *midiData++ = size;

  1450. 

  1451.                                 // set time

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

  1453.                                 midiData = midiData + 4;

  1454. 

  1455.                                 // set data

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

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

  1458. 

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

  1460.                             }

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

  1462.                             {

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

  1464. 

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

  1466.                                     break;

  1467. 

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

  1469. 

  1470.                                 // set size

  1471.                                 *midiData++ = _midiEvent.size;

  1472. 

  1473.                                 // set time

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

  1475.                                 midiData = midiData + 4;

  1476. 

  1477.                                 // set data

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

  1479. 

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

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

  1482. 

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

  1484.                             }

  1485.                         }

  1486. 

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

  1488.                     }

  1489. 

  1490.                 }   break;

  1491. 

  1492.                 case kPluginBridgeRtClientQuit: {

  1493.                     quitReceived = true;

  1494.                     signalThreadShouldExit();

  1495.                 }   break;

  1496.                 }

  1497.             }

  1498.         }

  1499. 

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

  1501. 

  1502.         if (! quitReceived)

  1503.         {

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

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

  1506. 

  1507.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1508.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1509.             fShmNonRtServerControl.writeUInt(messageSize);

  1510.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1511.             fShmNonRtServerControl.commitWrite();

  1512.         }

  1513.     }

  1514. 

  1515.     // called from process thread above

  1516.     EngineEvent* getNextFreeInputEvent() const noexcept

  1517.     {

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

  1519.         {

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

  1521. 

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

  1523.                 return event;

  1524.         }

  1525.         return nullptr;

  1526.     }

  1527. 

  1528.     // -------------------------------------------------------------------

  1529. 

  1530. private:

  1531.     BridgeAudioPool          fShmAudioPool;

  1532.     BridgeRtClientControl    fShmRtClientControl;

  1533.     BridgeNonRtClientControl fShmNonRtClientControl;

  1534.     BridgeNonRtServerControl fShmNonRtServerControl;

  1535. 

  1536.     bool fIsOffline;

  1537.     bool fFirstIdle;

  1538.     int64_t fLastPingTime;

  1539. 

  1540.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1541. };

  1542. 

  1543. // -----------------------------------------------------------------------

  1544. 

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

  1546. {

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

  1548. }

  1549. 

  1550. // -----------------------------------------------------------------------

  1551. 

  1552. #ifdef BRIDGE_PLUGIN

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

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

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

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

  1557. #endif

  1558. 

  1559. CARLA_BACKEND_END_NAMESPACE

  1560. 

  1561. // -----------------------------------------------------------------------

  1562. 

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

  1564. extern "C" __declspec (dllexport)

  1565. #else

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

  1567. #endif

  1568. void carla_register_native_plugin_carla();

  1569. void carla_register_native_plugin_carla(){}

  1570. 

  1571. // -----------------------------------------------------------------------