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

1472 lines
54KB
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. 

  36. template<typename T>

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

  38. {

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

  40.     return (value != nullptr);

  41. }

  42. 

  43. CARLA_BACKEND_START_NAMESPACE

  44. 

  45. // -------------------------------------------------------------------

  46. 

  47. struct BridgeAudioPool {

  48.     CarlaString filename;

  49.     float* data;

  50.     char shm[64];

  51. 

  52.     BridgeAudioPool() noexcept

  53.         : filename(),

  54.           data(nullptr)

  55.     {

  56.         carla_zeroChar(shm, 64);

  57.         jackbridge_shm_init(shm);

  58.     }

  59. 

  60.     ~BridgeAudioPool() noexcept

  61.     {

  62.         // should be cleared by now

  63.         CARLA_SAFE_ASSERT(data == nullptr);

  64. 

  65.         clear();

  66.     }

  67. 

  68.     void clear() noexcept

  69.     {

  70.         filename.clear();

  71. 

  72.         if (! jackbridge_shm_is_valid(shm))

  73.         {

  74.             CARLA_SAFE_ASSERT(data == nullptr);

  75.             return;

  76.         }

  77. 

  78.         data = nullptr;

  79. 

  80.         jackbridge_shm_close(shm);

  81.         jackbridge_shm_init(shm);

  82.     }

  83. 

  84.     bool attach() noexcept

  85.     {

  86.         // must be invalid right now

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

  88. 

  89.         jackbridge_shm_attach(shm, filename);

  90. 

  91.         return jackbridge_shm_is_valid(shm);

  92.     }

  93. 

  94.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeAudioPool)

  95. };

  96. 

  97. // -------------------------------------------------------------------

  98. 

  99. struct BridgeRtClientControl : public CarlaRingBufferControl<SmallStackBuffer> {

  100.     CarlaString filename;

  101.     BridgeRtClientData* data;

  102.     char shm[64];

  103. 

  104.     BridgeRtClientControl() noexcept

  105.         : filename(),

  106.           data(nullptr)

  107.     {

  108.         carla_zeroChar(shm, 64);

  109.         jackbridge_shm_init(shm);

  110.     }

  111. 

  112.     ~BridgeRtClientControl() noexcept override

  113.     {

  114.         // should be cleared by now

  115.         CARLA_SAFE_ASSERT(data == nullptr);

  116. 

  117.         clear();

  118.     }

  119. 

  120.     void clear() noexcept

  121.     {

  122.         filename.clear();

  123. 

  124.         if (data != nullptr)

  125.             unmapData();

  126. 

  127.         if (! jackbridge_shm_is_valid(shm))

  128.             return;

  129. 

  130.         jackbridge_shm_close(shm);

  131.         jackbridge_shm_init(shm);

  132.     }

  133. 

  134.     bool attach() noexcept

  135.     {

  136.         // must be invalid right now

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

  138. 

  139.         jackbridge_shm_attach(shm, filename);

  140. 

  141.         return jackbridge_shm_is_valid(shm);

  142.     }

  143. 

  144.     bool mapData() noexcept

  145.     {

  146.         CARLA_SAFE_ASSERT(data == nullptr);

  147. 

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

  149.         {

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

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

  152.             return true;

  153.         }

  154. 

  155.         return false;

  156.     }

  157. 

  158.     void unmapData() noexcept

  159.     {

  160.         data = nullptr;

  161.         setRingBuffer(nullptr, false);

  162.     }

  163. 

  164.     bool postClient() noexcept

  165.     {

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

  167. 

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

  169.     }

  170. 

  171.     bool waitForServer(const uint secs) noexcept

  172.     {

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

  174. 

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

  176.     }

  177. 

  178.     PluginBridgeRtClientOpcode readOpcode() noexcept

  179.     {

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

  181.     }

  182. 

  183.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeRtClientControl)

  184. };

  185. 

  186. // -------------------------------------------------------------------

  187. 

  188. struct BridgeNonRtClientControl : public CarlaRingBufferControl<BigStackBuffer> {

  189.     CarlaString filename;

  190.     BridgeNonRtClientData* data;

  191.     char shm[64];

  192. 

  193.     BridgeNonRtClientControl() noexcept

  194.         : filename(),

  195.           data(nullptr)

  196.     {

  197.         carla_zeroChar(shm, 64);

  198.         jackbridge_shm_init(shm);

  199.     }

  200. 

  201.     ~BridgeNonRtClientControl() noexcept override

  202.     {

  203.         // should be cleared by now

  204.         CARLA_SAFE_ASSERT(data == nullptr);

  205. 

  206.         clear();

  207.     }

  208. 

  209.     void clear() noexcept

  210.     {

  211.         filename.clear();

  212. 

  213.         if (data != nullptr)

  214.             unmapData();

  215. 

  216.         if (! jackbridge_shm_is_valid(shm))

  217.         {

  218.             CARLA_SAFE_ASSERT(data == nullptr);

  219.             return;

  220.         }

  221. 

  222.         jackbridge_shm_close(shm);

  223.         jackbridge_shm_init(shm);

  224.     }

  225. 

  226.     bool attach() noexcept

  227.     {

  228.         // must be invalid right now

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

  230. 

  231.         jackbridge_shm_attach(shm, filename);

  232. 

  233.         return jackbridge_shm_is_valid(shm);

  234.     }

  235. 

  236.     bool mapData() noexcept

  237.     {

  238.         CARLA_SAFE_ASSERT(data == nullptr);

  239. 

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

  241.         {

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

  243.             return true;

  244.         }

  245. 

  246.         return false;

  247.     }

  248. 

  249.     void unmapData() noexcept

  250.     {

  251.         data = nullptr;

  252.         setRingBuffer(nullptr, false);

  253.     }

  254. 

  255.     PluginBridgeNonRtClientOpcode readOpcode() noexcept

  256.     {

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

  258.     }

  259. 

  260.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtClientControl)

  261. };

  262. 

  263. // -------------------------------------------------------------------

  264. 

  265. struct BridgeNonRtServerControl : public CarlaRingBufferControl<HugeStackBuffer> {

  266.     CarlaMutex mutex;

  267.     CarlaString filename;

  268.     BridgeNonRtServerData* data;

  269.     char shm[64];

  270. 

  271.     BridgeNonRtServerControl() noexcept

  272.         :  mutex(),

  273.           filename(),

  274.           data(nullptr)

  275.     {

  276.         carla_zeroChar(shm, 64);

  277.         jackbridge_shm_init(shm);

  278.     }

  279. 

  280.     ~BridgeNonRtServerControl() noexcept override

  281.     {

  282.         // should be cleared by now

  283.         CARLA_SAFE_ASSERT(data == nullptr);

  284. 

  285.         clear();

  286.     }

  287. 

  288.     void clear() noexcept

  289.     {

  290.         filename.clear();

  291. 

  292.         if (data != nullptr)

  293.             unmapData();

  294. 

  295.         if (! jackbridge_shm_is_valid(shm))

  296.         {

  297.             CARLA_SAFE_ASSERT(data == nullptr);

  298.             return;

  299.         }

  300. 

  301.         jackbridge_shm_close(shm);

  302.         jackbridge_shm_init(shm);

  303.     }

  304. 

  305.     bool attach() noexcept

  306.     {

  307.         // must be invalid right now

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

  309. 

  310.         jackbridge_shm_attach(shm, filename);

  311. 

  312.         return jackbridge_shm_is_valid(shm);

  313.     }

  314. 

  315.     bool mapData() noexcept

  316.     {

  317.         CARLA_SAFE_ASSERT(data == nullptr);

  318. 

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

  320.         {

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

  322.             return true;

  323.         }

  324. 

  325.         return false;

  326.     }

  327. 

  328.     void unmapData() noexcept

  329.     {

  330.         data = nullptr;

  331.         setRingBuffer(nullptr, false);

  332.     }

  333. 

  334.     void writeOpcode(const PluginBridgeNonRtServerOpcode opcode) noexcept

  335.     {

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

  337.     }

  338. 

  339.     void waitIfDataIsReachingLimit() noexcept

  340.     {

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

  342.             return;

  343. 

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

  345.         {

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

  347.             {

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

  349.                 writeOpcode(kPluginBridgeNonRtServerPong);

  350.                 commitWrite();

  351.                 return;

  352.             }

  353.             carla_msleep(20);

  354.         }

  355. 

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

  357.     }

  358. 

  359.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtServerControl)

  360. };

  361. 

  362. // -------------------------------------------------------------------

  363. 

  364. class CarlaEngineBridge : public CarlaEngine,

  365.                           public CarlaThread

  366. {

  367. public:

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

  369.         : CarlaEngine(),

  370.           CarlaThread("CarlaEngineBridge"),

  371.           fShmAudioPool(),

  372.           fShmRtClientControl(),

  373.           fShmNonRtClientControl(),

  374.           fShmNonRtServerControl(),

  375.           fIsOffline(false),

  376.           fFirstIdle(true),

  377.           fLastPingCounter(-1),

  378.           leakDetector_CarlaEngineBridge()

  379.     {

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

  381. 

  382.         fShmAudioPool.filename  = PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL;

  383.         fShmAudioPool.filename += audioPoolBaseName;

  384. 

  385.         fShmRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_RT_CLIENT;

  386.         fShmRtClientControl.filename += rtClientBaseName;

  387. 

  388.         fShmNonRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT;

  389.         fShmNonRtClientControl.filename += nonRtClientBaseName;

  390. 

  391.         fShmNonRtServerControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER;

  392.         fShmNonRtServerControl.filename += nonRtServerBaseName;

  393.     }

  394. 

  395.     ~CarlaEngineBridge() noexcept override

  396.     {

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

  398. 

  399.         clear();

  400.     }

  401. 

  402.     // -------------------------------------

  403.     // CarlaEngine virtual calls

  404. 

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

  406.     {

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

  408. 

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

  410.         {

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

  412.             return false;

  413.         }

  414. 

  415.         if (! fShmAudioPool.attach())

  416.         {

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

  418.             return false;

  419.         }

  420. 

  421.         if (! fShmRtClientControl.attach())

  422.         {

  423.             clear();

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

  425.             return false;

  426.         }

  427. 

  428.         if (! fShmRtClientControl.mapData())

  429.         {

  430.             clear();

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

  432.             return false;

  433.         }

  434. 

  435.         if (! fShmNonRtClientControl.attach())

  436.         {

  437.             clear();

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

  439.             return false;

  440.         }

  441. 

  442.         if (! fShmNonRtClientControl.mapData())

  443.         {

  444.             clear();

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

  446.             return false;

  447.         }

  448. 

  449.         if (! fShmNonRtServerControl.attach())

  450.         {

  451.             clear();

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

  453.             return false;

  454.         }

  455. 

  456.         if (! fShmNonRtServerControl.mapData())

  457.         {

  458.             clear();

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

  460.             return false;

  461.         }

  462. 

  463.         PluginBridgeNonRtClientOpcode opcode;

  464. 

  465.         opcode = fShmNonRtClientControl.readOpcode();

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

  467. 

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

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

  470. 

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

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

  473. 

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

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

  476. 

  477.         opcode = fShmNonRtClientControl.readOpcode();

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

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

  480. 

  481.         opcode = fShmNonRtClientControl.readOpcode();

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

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

  484. 

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

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

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

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

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

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

  491. 

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

  493.             return false;

  494. 

  495.         startThread();

  496. 

  497.         return true;

  498.     }

  499. 

  500.     bool close() override

  501.     {

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

  503.         fLastPingCounter = -1;

  504. 

  505.         CarlaEngine::close();

  506. 

  507.         stopThread(5000);

  508.         clear();

  509. 

  510.         return true;

  511.     }

  512. 

  513.     bool isRunning() const noexcept override

  514.     {

  515.         return isThreadRunning() || ! fFirstIdle;

  516.     }

  517. 

  518.     bool isOffline() const noexcept override

  519.     {

  520.         return fIsOffline;

  521.     }

  522. 

  523.     EngineType getType() const noexcept override

  524.     {

  525.         return kEngineTypeBridge;

  526.     }

  527. 

  528.     const char* getCurrentDriverName() const noexcept

  529.     {

  530.         return "Bridge";

  531.     }

  532. 

  533.     void idle() noexcept override

  534.     {

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

  536.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  537. 

  538.         if (fFirstIdle)

  539.         {

  540.             fFirstIdle = false;

  541.             fLastPingCounter = 0;

  542. 

  543.             char bufStr[STR_MAX+1];

  544.             uint32_t bufStrSize;

  545. 

  546.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  547. 

  548.             // kPluginBridgeNonRtServerPluginInfo1

  549.             {

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

  551.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  557.                 fShmNonRtServerControl.commitWrite();

  558.             }

  559. 

  560.             // kPluginBridgeNonRtServerPluginInfo2

  561.             {

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

  563.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  564. 

  565.                 carla_zeroChar(bufStr, STR_MAX);

  566.                 plugin->getRealName(bufStr);

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

  568.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  569.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  570. 

  571.                 carla_zeroChar(bufStr, STR_MAX);

  572.                 plugin->getLabel(bufStr);

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

  574.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  575.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  576. 

  577.                 carla_zeroChar(bufStr, STR_MAX);

  578.                 plugin->getMaker(bufStr);

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

  580.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  581.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  582. 

  583.                 carla_zeroChar(bufStr, STR_MAX);

  584.                 plugin->getCopyright(bufStr);

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

  586.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  587.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  588. 

  589.                 fShmNonRtServerControl.commitWrite();

  590.             }

  591. 

  592.             // kPluginBridgeNonRtServerAudioCount

  593.             {

  594.                 // uint/ins, uint/outs

  595.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

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

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

  598.                 fShmNonRtServerControl.commitWrite();

  599.             }

  600. 

  601.             // kPluginBridgeNonRtServerMidiCount

  602.             {

  603.                 // uint/ins, uint/outs

  604.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  607.                 fShmNonRtServerControl.commitWrite();

  608.             }

  609. 

  610.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  611. 

  612.             // kPluginBridgeNonRtServerParameter*

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

  614.             {

  615.                 // uint/count

  616.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  617.                 fShmNonRtServerControl.writeUInt(count);

  618.                 fShmNonRtServerControl.commitWrite();

  619. 

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

  621.                 {

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

  623. 

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

  625.                         continue;

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

  627.                         continue;

  628. 

  629.                     // kPluginBridgeNonRtServerParameterData1

  630.                     {

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

  632.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  633.                         fShmNonRtServerControl.writeUInt(i);

  634.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  635.                         fShmNonRtServerControl.writeUInt(paramData.type);

  636.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  637.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  638.                         fShmNonRtServerControl.commitWrite();

  639.                     }

  640. 

  641.                     // kPluginBridgeNonRtServerParameterData2

  642.                     {

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

  644.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  645.                         fShmNonRtServerControl.writeUInt(i);

  646. 

  647.                         carla_zeroChar(bufStr, STR_MAX);

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

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

  650.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  651.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  652. 

  653.                         carla_zeroChar(bufStr, STR_MAX);

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

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

  656.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  657.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  658. 

  659.                         carla_zeroChar(bufStr, STR_MAX);

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

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

  662.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  663.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  664. 

  665.                         fShmNonRtServerControl.commitWrite();

  666.                     }

  667. 

  668.                     // kPluginBridgeNonRtServerParameterRanges

  669.                     {

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

  671. 

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

  673.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  674.                         fShmNonRtServerControl.writeUInt(i);

  675.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  676.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  677.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  678.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  679.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  680.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  681.                         fShmNonRtServerControl.commitWrite();

  682.                     }

  683. 

  684.                     // kPluginBridgeNonRtServerParameterValue2

  685.                     {

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

  687.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  688.                         fShmNonRtServerControl.writeUInt(i);

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

  690.                         fShmNonRtServerControl.commitWrite();

  691.                     }

  692. 

  693.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  694.                 }

  695.             }

  696. 

  697.             // kPluginBridgeNonRtServerProgram*

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

  699.             {

  700.                 // uint/count

  701.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  702.                 fShmNonRtServerControl.writeUInt(count);

  703.                 fShmNonRtServerControl.commitWrite();

  704. 

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

  706.                 {

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

  708.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  709.                     fShmNonRtServerControl.writeUInt(i);

  710. 

  711.                     carla_zeroChar(bufStr, STR_MAX);

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

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

  714.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  715.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  716. 

  717.                     fShmNonRtServerControl.commitWrite();

  718.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  719.                 }

  720.             }

  721. 

  722.             // kPluginBridgeNonRtServerMidiProgram*

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

  724.             {

  725.                 // uint/count

  726.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  727.                 fShmNonRtServerControl.writeUInt(count);

  728.                 fShmNonRtServerControl.commitWrite();

  729. 

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

  731.                 {

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

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

  734. 

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

  736.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  737.                     fShmNonRtServerControl.writeUInt(i);

  738.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  739.                     fShmNonRtServerControl.writeUInt(mpData.program);

  740. 

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

  742.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  744. 

  745.                     fShmNonRtServerControl.commitWrite();

  746.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  747.                 }

  748.             }

  749. 

  750.             // ready!

  751.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  752.             fShmNonRtServerControl.commitWrite();

  753.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  754. 

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

  756.         }

  757. 

  758.         // send parameter outputs

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

  760.         {

  761.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  762. 

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

  764.             {

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

  766.                     continue;

  767. 

  768.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  769.                 fShmNonRtServerControl.writeUInt(i);

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

  771. 

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

  773.                 if (! fShmNonRtServerControl.commitWrite())

  774.                     break;

  775.             }

  776.         }

  777. 

  778.         CarlaEngine::idle();

  779. 

  780.         try {

  781.             handleNonRtData();

  782.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  783. 

  784.         if (fLastPingCounter >= 0 && ++fLastPingCounter == 500)

  785.         {

  786.             carla_stderr("Did not receive ping message from server for a long time, closing...");

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

  788.         }

  789.     }

  790. 

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

  792.     {

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

  794. 

  795.         if (fLastPingCounter < 0)

  796.             return;

  797. 

  798.         switch (action)

  799.         {

  800.         // uint/index float/value

  801.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  802.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  803.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  804.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  806.             fShmNonRtServerControl.writeFloat(value3);

  807.             fShmNonRtServerControl.commitWrite();

  808.         }   break;

  809. 

  810.         // uint/index float/value

  811.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  812.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  813.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  814.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  816.             fShmNonRtServerControl.writeFloat(value3);

  817.             fShmNonRtServerControl.commitWrite();

  818.         }   break;

  819. 

  820.         // int/index

  821.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  822.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  823.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  824.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  825.             fShmNonRtServerControl.writeInt(value1);

  826.             fShmNonRtServerControl.commitWrite();

  827.         }   break;

  828. 

  829.         // int/index

  830.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  831.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  832.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  833.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  834.             fShmNonRtServerControl.writeInt(value1);

  835.             fShmNonRtServerControl.commitWrite();

  836.         }   break;

  837. 

  838.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  839.             if (value1 != 1)

  840.             {

  841.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  842.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  843.                 fShmNonRtServerControl.commitWrite();

  844.             }

  845.             break;

  846. 

  847.         default:

  848.             break;

  849.         }

  850.     }

  851. 

  852.     // -------------------------------------------------------------------

  853. 

  854.     void clear() noexcept

  855.     {

  856.         fShmAudioPool.clear();

  857.         fShmRtClientControl.clear();

  858.         fShmNonRtClientControl.clear();

  859.         fShmNonRtServerControl.clear();

  860.     }

  861. 

  862.     void handleNonRtData()

  863.     {

  864.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  865.         {

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

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

  868. 

  869. #ifdef DEBUG

  870.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  872.             }

  873. #endif

  874. 

  875.             if (opcode != kPluginBridgeNonRtClientNull && fLastPingCounter > 0)

  876.                 fLastPingCounter = 0;

  877. 

  878.             switch (opcode)

  879.             {

  880.             case kPluginBridgeNonRtClientNull:

  881.                 break;

  882. 

  883.             case kPluginBridgeNonRtClientPing: {

  884.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  885. 

  886.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  887.                 fShmNonRtServerControl.commitWrite();

  888.             }   break;

  889. 

  890.             case kPluginBridgeNonRtClientActivate:

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

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

  893.                 break;

  894. 

  895.             case kPluginBridgeNonRtClientDeactivate:

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

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

  898.                 break;

  899. 

  900.             case kPluginBridgeNonRtClientSetBufferSize: {

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

  902.                 pData->bufferSize = bufferSize;

  903.                 bufferSizeChanged(bufferSize);

  904.                 break;

  905.             }

  906. 

  907.             case kPluginBridgeNonRtClientSetSampleRate: {

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

  909.                 pData->sampleRate = sampleRate;

  910.                 sampleRateChanged(sampleRate);

  911.                 break;

  912.             }

  913. 

  914.             case kPluginBridgeNonRtClientSetOffline:

  915.                 fIsOffline = true;

  916.                 offlineModeChanged(true);

  917.                 break;

  918. 

  919.             case kPluginBridgeNonRtClientSetOnline:

  920.                 fIsOffline = false;

  921.                 offlineModeChanged(false);

  922.                 break;

  923. 

  924.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  927. 

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

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

  930.                 break;

  931.             }

  932. 

  933.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  936. 

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

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

  939.                 break;

  940.             }

  941. 

  942.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  945. 

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

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

  948.                 break;

  949.             }

  950. 

  951.             case kPluginBridgeNonRtClientSetProgram: {

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

  953. 

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

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

  956.                 break;

  957.             }

  958. 

  959.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  961. 

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

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

  964.                 break;

  965.             }

  966. 

  967.             case kPluginBridgeNonRtClientSetCustomData: {

  968.                 // type

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

  970.                 char typeStr[typeSize+1];

  971.                 carla_zeroChar(typeStr, typeSize+1);

  972.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  973. 

  974.                 // key

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

  976.                 char keyStr[keySize+1];

  977.                 carla_zeroChar(keyStr, keySize+1);

  978.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  979. 

  980.                 // value

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

  982.                 char valueStr[valueSize+1];

  983.                 carla_zeroChar(valueStr, valueSize+1);

  984.                 fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  985. 

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

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

  988.                 break;

  989.             }

  990. 

  991.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  993.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  994. 

  995.                 char chunkFilePathTry[size+1];

  996.                 carla_zeroChar(chunkFilePathTry, size+1);

  997.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  998. 

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

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

  1001. 

  1002.                 String chunkFilePath(chunkFilePathTry);

  1003. 

  1004. #ifdef CARLA_OS_WIN

  1005.                 // check if running under Wine

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

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

  1008. #endif

  1009. 

  1010.                 File chunkFile(chunkFilePath);

  1011.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  1012. 

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

  1014.                 chunkFile.deleteFile();

  1015.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  1016. 

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

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

  1019.                 break;

  1020.             }

  1021. 

  1022.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  1025. 

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

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

  1028.                 break;

  1029.             }

  1030. 

  1031.             case kPluginBridgeNonRtClientSetOption: {

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

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

  1034. 

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

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

  1037.                 break;

  1038.             }

  1039. 

  1040.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1042. 

  1043.                 plugin->prepareForSave();

  1044. 

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

  1046.                 {

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

  1048. 

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

  1050.                         continue;

  1051. 

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

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

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

  1055. 

  1056.                     {

  1057.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1058. 

  1059.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1060. 

  1061.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1063. 

  1064.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1066. 

  1067.                         fShmNonRtServerControl.writeUInt(valueLen);

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

  1069. 

  1070.                         fShmNonRtServerControl.commitWrite();

  1071.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1072.                     }

  1073.                 }

  1074. 

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

  1076.                 {

  1077.                     void* data = nullptr;

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

  1079.                     {

  1080.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1081. 

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

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

  1084. 

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

  1086. 

  1087.                         filePath += CARLA_OS_SEP_STR;

  1088.                         filePath += ".CarlaChunk_";

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

  1090. 

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

  1092.                         {

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

  1094. 

  1095.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1096. 

  1097.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1098.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1100.                             fShmNonRtServerControl.commitWrite();

  1101.                         }

  1102.                     }

  1103.                 }

  1104. 

  1105.                 {

  1106.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1107. 

  1108.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1109.                     fShmNonRtServerControl.commitWrite();

  1110.                 }

  1111.                 break;

  1112.             }

  1113. 

  1114.             case kPluginBridgeNonRtClientShowUI:

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

  1116.                     plugin->showCustomUI(true);

  1117.                 break;

  1118. 

  1119.             case kPluginBridgeNonRtClientHideUI:

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

  1121.                     plugin->showCustomUI(false);

  1122.                 break;

  1123. 

  1124.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1127. 

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

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

  1130.                 break;

  1131.             }

  1132. 

  1133.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1135. 

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

  1137.                     plugin->uiProgramChange(index);

  1138.                 break;

  1139.             }

  1140. 

  1141.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1143. 

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

  1145.                     plugin->uiMidiProgramChange(index);

  1146.                 break;

  1147.             }

  1148. 

  1149.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1153. 

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

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

  1156.                 break;

  1157.             }

  1158. 

  1159.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1162. 

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

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

  1165.                 break;

  1166.             }

  1167. 

  1168.             case kPluginBridgeNonRtClientQuit:

  1169.                 signalThreadShouldExit();

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

  1171.                 break;

  1172.             }

  1173.         }

  1174.     }

  1175. 

  1176.     // -------------------------------------------------------------------

  1177. 

  1178. protected:

  1179.     void run() override

  1180.     {

  1181.         for (; ! shouldThreadExit();)

  1182.         {

  1183.             if (! fShmRtClientControl.waitForServer(5))

  1184.             {

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

  1186.                 fShmRtClientControl.postClient();

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

  1188.                 signalThreadShouldExit();

  1189.                 break;

  1190.             }

  1191. 

  1192.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1193.             {

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

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

  1196. 

  1197. #ifdef DEBUG

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

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

  1200.                 }

  1201. #endif

  1202. 

  1203.                 switch (opcode)

  1204.                 {

  1205.                 case kPluginBridgeRtClientNull:

  1206.                     break;

  1207. 

  1208.                 case kPluginBridgeRtClientSetAudioPool: {

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

  1210.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1212.                     break;

  1213.                 }

  1214. 

  1215.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1220. 

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

  1222.                     {

  1223.                         event->type    = kEngineEventTypeControl;

  1224.                         event->time    = time;

  1225.                         event->channel = channel;

  1226.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1227.                         event->ctrl.param = param;

  1228.                         event->ctrl.value = value;

  1229.                     }

  1230.                     break;

  1231.                 }

  1232. 

  1233.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1237. 

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

  1239.                     {

  1240.                         event->type    = kEngineEventTypeControl;

  1241.                         event->time    = time;

  1242.                         event->channel = channel;

  1243.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1244.                         event->ctrl.param = index;

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

  1246.                     }

  1247.                     break;

  1248.                 }

  1249. 

  1250.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1254. 

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

  1256.                     {

  1257.                         event->type    = kEngineEventTypeControl;

  1258.                         event->time    = time;

  1259.                         event->channel = channel;

  1260.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1261.                         event->ctrl.param = index;

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

  1263.                     }

  1264.                     break;

  1265.                 }

  1266. 

  1267.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1270. 

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

  1272.                     {

  1273.                         event->type    = kEngineEventTypeControl;

  1274.                         event->time    = time;

  1275.                         event->channel = channel;

  1276.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1277.                         event->ctrl.param = 0;

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

  1279.                     }

  1280.                 }

  1281. 

  1282.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1285. 

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

  1287.                     {

  1288.                         event->type    = kEngineEventTypeControl;

  1289.                         event->time    = time;

  1290.                         event->channel = channel;

  1291.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1292.                         event->ctrl.param = 0;

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

  1294.                     }

  1295.                 }

  1296. 

  1297.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1301.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1302. 

  1303.                     uint8_t data[size];

  1304. 

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

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

  1307. 

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

  1309.                     {

  1310.                         event->type    = kEngineEventTypeMidi;

  1311.                         event->time    = time;

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

  1313. 

  1314.                         event->midi.port = port;

  1315.                         event->midi.size = size;

  1316. 

  1317.                         if (size > EngineMidiEvent::kDataSize)

  1318.                         {

  1319.                             event->midi.dataExt = data;

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

  1321.                         }

  1322.                         else

  1323.                         {

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

  1325. 

  1326.                             uint8_t i=1;

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

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

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

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

  1331. 

  1332.                             event->midi.dataExt = nullptr;

  1333.                         }

  1334.                     }

  1335.                     break;

  1336.                 }

  1337. 

  1338.                 case kPluginBridgeRtClientProcess: {

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

  1340. 

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

  1342.                     {

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

  1344. 

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

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

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

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

  1349. 

  1350.                         const float* audioIn[audioInCount];

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

  1352.                         const float* cvIn[cvInCount];

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

  1354. 

  1355.                         float* fdata = fShmAudioPool.data;

  1356. 

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

  1358.                             audioIn[i] = fdata;

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

  1360.                             audioOut[i] = fdata;

  1361. 

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

  1363.                             cvIn[i] = fdata;

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

  1365.                             cvOut[i] = fdata;

  1366. 

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

  1368. 

  1369.                         timeInfo.playing = bridgeTimeInfo.playing;

  1370.                         timeInfo.frame   = bridgeTimeInfo.frame;

  1371.                         timeInfo.usecs   = bridgeTimeInfo.usecs;

  1372.                         timeInfo.valid   = bridgeTimeInfo.valid;

  1373. 

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

  1375.                         {

  1376.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1377.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1378.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1379. 

  1380.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1381.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1382. 

  1383.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1384.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1385.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1386.                         }

  1387. 

  1388.                         plugin->initBuffers();

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

  1390.                         plugin->unlock();

  1391.                     }

  1392. 

  1393.                     // clear buffer

  1394.                     CARLA_SAFE_ASSERT_BREAK(pData->events.in != nullptr);

  1395. 

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

  1397.                         carla_zeroStruct<EngineEvent>(pData->events.in, kMaxEngineEventInternalCount);

  1398. 

  1399.                     break;

  1400.                 }

  1401. 

  1402.                 case kPluginBridgeRtClientQuit:

  1403.                     signalThreadShouldExit();

  1404.                     break;

  1405.                 }

  1406.             }

  1407. 

  1408.             if (! fShmRtClientControl.postClient())

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

  1410.         }

  1411. 

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

  1413.     }

  1414. 

  1415.     // called from process thread above

  1416.     EngineEvent* getNextFreeInputEvent() const noexcept

  1417.     {

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

  1419.         {

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

  1421. 

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

  1423.                 return event;

  1424.         }

  1425.         return nullptr;

  1426.     }

  1427. 

  1428.     // -------------------------------------------------------------------

  1429. 

  1430. private:

  1431.     BridgeAudioPool          fShmAudioPool;

  1432.     BridgeRtClientControl    fShmRtClientControl;

  1433.     BridgeNonRtClientControl fShmNonRtClientControl;

  1434.     BridgeNonRtServerControl fShmNonRtServerControl;

  1435. 

  1436.     bool fIsOffline;

  1437.     bool fFirstIdle;

  1438.     int32_t fLastPingCounter;

  1439. 

  1440.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1441. };

  1442. 

  1443. // -----------------------------------------------------------------------

  1444. 

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

  1446. {

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

  1448. }

  1449. 

  1450. // -----------------------------------------------------------------------

  1451. 

  1452. #ifdef BRIDGE_PLUGIN

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

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

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

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

  1457. #endif

  1458. 

  1459. CARLA_BACKEND_END_NAMESPACE

  1460. 

  1461. // -----------------------------------------------------------------------

  1462. 

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

  1464. extern "C" __declspec (dllexport)

  1465. #else

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

  1467. #endif

  1468. void carla_register_native_plugin_carla();

  1469. void carla_register_native_plugin_carla(){}

  1470. 

  1471. // -----------------------------------------------------------------------