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

1622 lines
60KB
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. 

  155.             CARLA_SAFE_ASSERT_RETURN(jackbridge_sem_connect(&data->sem.server), false);

  156.             CARLA_SAFE_ASSERT_RETURN(jackbridge_sem_connect(&data->sem.client), false);

  157.             return true;

  158.         }

  159. 

  160.         return false;

  161.     }

  162. 

  163.     void unmapData() noexcept

  164.     {

  165.         data = nullptr;

  166.         setRingBuffer(nullptr, false);

  167.     }

  168. 

  169.     PluginBridgeRtClientOpcode readOpcode() noexcept

  170.     {

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

  172.     }

  173. 

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

  175.     struct WaitHelper {

  176.         BridgeRtClientData* const data;

  177.         const bool ok;

  178. 

  179.         WaitHelper(BridgeRtClientControl& c) noexcept

  180.             : data(c.data),

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

  182. 

  183.         ~WaitHelper() noexcept

  184.         {

  185.             if (ok)

  186.                 jackbridge_sem_post(&data->sem.client, false);

  187.         }

  188. 

  189.         CARLA_DECLARE_NON_COPY_STRUCT(WaitHelper)

  190.     };

  191. 

  192.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeRtClientControl)

  193. };

  194. 

  195. // -------------------------------------------------------------------

  196. 

  197. struct BridgeNonRtClientControl : public CarlaRingBufferControl<BigStackBuffer> {

  198.     CarlaString filename;

  199.     BridgeNonRtClientData* data;

  200.     char shm[64];

  201. 

  202.     BridgeNonRtClientControl() noexcept

  203.         : filename(),

  204.           data(nullptr)

  205.     {

  206.         carla_zeroChars(shm, 64);

  207.         jackbridge_shm_init(shm);

  208.     }

  209. 

  210.     ~BridgeNonRtClientControl() noexcept override

  211.     {

  212.         // should be cleared by now

  213.         CARLA_SAFE_ASSERT(data == nullptr);

  214. 

  215.         clear();

  216.     }

  217. 

  218.     void clear() noexcept

  219.     {

  220.         filename.clear();

  221. 

  222.         if (data != nullptr)

  223.             unmapData();

  224. 

  225.         if (! jackbridge_shm_is_valid(shm))

  226.         {

  227.             CARLA_SAFE_ASSERT(data == nullptr);

  228.             return;

  229.         }

  230. 

  231.         jackbridge_shm_close(shm);

  232.         jackbridge_shm_init(shm);

  233.     }

  234. 

  235.     bool attach() noexcept

  236.     {

  237.         // must be invalid right now

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

  239. 

  240.         jackbridge_shm_attach(shm, filename);

  241. 

  242.         return jackbridge_shm_is_valid(shm);

  243.     }

  244. 

  245.     bool mapData() noexcept

  246.     {

  247.         CARLA_SAFE_ASSERT(data == nullptr);

  248. 

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

  250.         {

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

  252.             return true;

  253.         }

  254. 

  255.         return false;

  256.     }

  257. 

  258.     void unmapData() noexcept

  259.     {

  260.         data = nullptr;

  261.         setRingBuffer(nullptr, false);

  262.     }

  263. 

  264.     PluginBridgeNonRtClientOpcode readOpcode() noexcept

  265.     {

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

  267.     }

  268. 

  269.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtClientControl)

  270. };

  271. 

  272. // -------------------------------------------------------------------

  273. 

  274. struct BridgeNonRtServerControl : public CarlaRingBufferControl<HugeStackBuffer> {

  275.     CarlaMutex mutex;

  276.     CarlaString filename;

  277.     BridgeNonRtServerData* data;

  278.     char shm[64];

  279. 

  280.     BridgeNonRtServerControl() noexcept

  281.         :  mutex(),

  282.            filename(),

  283.            data(nullptr)

  284.     {

  285.         carla_zeroChars(shm, 64);

  286.         jackbridge_shm_init(shm);

  287.     }

  288. 

  289.     ~BridgeNonRtServerControl() noexcept override

  290.     {

  291.         // should be cleared by now

  292.         CARLA_SAFE_ASSERT(data == nullptr);

  293. 

  294.         clear();

  295.     }

  296. 

  297.     void clear() noexcept

  298.     {

  299.         filename.clear();

  300. 

  301.         if (data != nullptr)

  302.             unmapData();

  303. 

  304.         if (! jackbridge_shm_is_valid(shm))

  305.         {

  306.             CARLA_SAFE_ASSERT(data == nullptr);

  307.             return;

  308.         }

  309. 

  310.         jackbridge_shm_close(shm);

  311.         jackbridge_shm_init(shm);

  312.     }

  313. 

  314.     bool attach() noexcept

  315.     {

  316.         // must be invalid right now

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

  318. 

  319.         jackbridge_shm_attach(shm, filename);

  320. 

  321.         return jackbridge_shm_is_valid(shm);

  322.     }

  323. 

  324.     bool mapData() noexcept

  325.     {

  326.         CARLA_SAFE_ASSERT(data == nullptr);

  327. 

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

  329.         {

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

  331.             return true;

  332.         }

  333. 

  334.         return false;

  335.     }

  336. 

  337.     void unmapData() noexcept

  338.     {

  339.         data = nullptr;

  340.         setRingBuffer(nullptr, false);

  341.     }

  342. 

  343.     void writeOpcode(const PluginBridgeNonRtServerOpcode opcode) noexcept

  344.     {

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

  346.     }

  347. 

  348.     void waitIfDataIsReachingLimit() noexcept

  349.     {

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

  351.             return;

  352. 

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

  354.         {

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

  356.             {

  357.                 writeOpcode(kPluginBridgeNonRtServerPong);

  358.                 commitWrite();

  359.                 return;

  360.             }

  361.             carla_msleep(20);

  362.         }

  363. 

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

  365.     }

  366. 

  367.     CARLA_DECLARE_NON_COPY_STRUCT(BridgeNonRtServerControl)

  368. };

  369. 

  370. // -------------------------------------------------------------------

  371. 

  372. class CarlaEngineBridge : public CarlaEngine,

  373.                           public Thread

  374. {

  375. public:

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

  377.         : CarlaEngine(),

  378.           Thread("CarlaEngineBridge"),

  379.           fShmAudioPool(),

  380.           fShmRtClientControl(),

  381.           fShmNonRtClientControl(),

  382.           fShmNonRtServerControl(),

  383.           fIsOffline(false),

  384.           fFirstIdle(true),

  385.           fLastPingTime(-1)

  386.     {

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

  388. 

  389.         fShmAudioPool.filename  = PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL;

  390.         fShmAudioPool.filename += audioPoolBaseName;

  391. 

  392.         fShmRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_RT_CLIENT;

  393.         fShmRtClientControl.filename += rtClientBaseName;

  394. 

  395.         fShmNonRtClientControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT;

  396.         fShmNonRtClientControl.filename += nonRtClientBaseName;

  397. 

  398.         fShmNonRtServerControl.filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER;

  399.         fShmNonRtServerControl.filename += nonRtServerBaseName;

  400.     }

  401. 

  402.     ~CarlaEngineBridge() noexcept override

  403.     {

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

  405. 

  406.         clear();

  407.     }

  408. 

  409.     // -------------------------------------

  410.     // CarlaEngine virtual calls

  411. 

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

  413.     {

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

  415. 

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

  417.         {

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

  419.             return false;

  420.         }

  421. 

  422.         if (! fShmAudioPool.attach())

  423.         {

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

  425.             return false;

  426.         }

  427. 

  428.         if (! fShmRtClientControl.attach())

  429.         {

  430.             clear();

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

  432.             return false;

  433.         }

  434. 

  435.         if (! fShmRtClientControl.mapData())

  436.         {

  437.             clear();

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

  439.             return false;

  440.         }

  441. 

  442.         if (! fShmNonRtClientControl.attach())

  443.         {

  444.             clear();

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

  446.             return false;

  447.         }

  448. 

  449.         if (! fShmNonRtClientControl.mapData())

  450.         {

  451.             clear();

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

  453.             return false;

  454.         }

  455. 

  456.         if (! fShmNonRtServerControl.attach())

  457.         {

  458.             clear();

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

  460.             return false;

  461.         }

  462. 

  463.         if (! fShmNonRtServerControl.mapData())

  464.         {

  465.             clear();

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

  467.             return false;

  468.         }

  469. 

  470.         PluginBridgeNonRtClientOpcode opcode;

  471. 

  472.         opcode = fShmNonRtClientControl.readOpcode();

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

  474. 

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

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

  477. 

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

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

  480. 

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

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

  483. 

  484.         opcode = fShmNonRtClientControl.readOpcode();

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

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

  487. 

  488.         opcode = fShmNonRtClientControl.readOpcode();

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

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

  491. 

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

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

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

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

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

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

  498. 

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

  500.             return false;

  501. 

  502.         // tell backend we're live

  503.         {

  504.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  505. 

  506.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  507.             fShmNonRtServerControl.commitWrite();

  508.         }

  509. 

  510.         startThread(10);

  511. 

  512.         return true;

  513.     }

  514. 

  515.     bool close() override

  516.     {

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

  518.         fLastPingTime = -1;

  519. 

  520.         CarlaEngine::close();

  521. 

  522.         stopThread(5000);

  523.         clear();

  524. 

  525.         return true;

  526.     }

  527. 

  528.     bool isRunning() const noexcept override

  529.     {

  530.         return isThreadRunning() || ! fFirstIdle;

  531.     }

  532. 

  533.     bool isOffline() const noexcept override

  534.     {

  535.         return fIsOffline;

  536.     }

  537. 

  538.     EngineType getType() const noexcept override

  539.     {

  540.         return kEngineTypeBridge;

  541.     }

  542. 

  543.     const char* getCurrentDriverName() const noexcept override

  544.     {

  545.         return "Bridge";

  546.     }

  547. 

  548.     void idle() noexcept override

  549.     {

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

  551.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  552. 

  553.         const bool wasFirstIdle(fFirstIdle);

  554. 

  555.         if (fFirstIdle)

  556.         {

  557.             fFirstIdle = false;

  558.             fLastPingTime = Time::currentTimeMillis();

  559.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  560. 

  561.             char bufStr[STR_MAX+1];

  562.             uint32_t bufStrSize;

  563. 

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

  565.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  566. 

  567.             // kPluginBridgeNonRtServerPluginInfo1

  568.             {

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

  570.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

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

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

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

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

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

  576.                 fShmNonRtServerControl.commitWrite();

  577.             }

  578. 

  579.             // kPluginBridgeNonRtServerPluginInfo2

  580.             {

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

  582.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  583. 

  584.                 carla_zeroChars(bufStr, STR_MAX);

  585.                 plugin->getRealName(bufStr);

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

  587.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  588.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  589. 

  590.                 carla_zeroChars(bufStr, STR_MAX);

  591.                 plugin->getLabel(bufStr);

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

  593.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  594.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  595. 

  596.                 carla_zeroChars(bufStr, STR_MAX);

  597.                 plugin->getMaker(bufStr);

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

  599.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  600.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  601. 

  602.                 carla_zeroChars(bufStr, STR_MAX);

  603.                 plugin->getCopyright(bufStr);

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

  605.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  606.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  607. 

  608.                 fShmNonRtServerControl.commitWrite();

  609.             }

  610. 

  611.             // kPluginBridgeNonRtServerAudioCount

  612.             {

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

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

  615. 

  616.                 // uint/ins, uint/outs

  617.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  618.                 fShmNonRtServerControl.writeUInt(aIns);

  619.                 fShmNonRtServerControl.writeUInt(aOuts);

  620.                 fShmNonRtServerControl.commitWrite();

  621. 

  622.                 // kPluginBridgeNonRtServerPortName

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

  624.                 {

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

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

  627. 

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

  629.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  630.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  631.                     fShmNonRtServerControl.writeUInt(i);

  632. 

  633.                     bufStrSize = std::strlen(portName);

  634.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  635.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  636.                 }

  637. 

  638.                 // kPluginBridgeNonRtServerPortName

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

  640.                 {

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

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

  643. 

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

  645.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  646.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  647.                     fShmNonRtServerControl.writeUInt(i);

  648. 

  649.                     bufStrSize = std::strlen(portName);

  650.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  651.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  652.                 }

  653.             }

  654. 

  655.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  656. 

  657.             // kPluginBridgeNonRtServerMidiCount

  658.             {

  659.                 // uint/ins, uint/outs

  660.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

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

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

  663.                 fShmNonRtServerControl.commitWrite();

  664.             }

  665. 

  666.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  667. 

  668.             // kPluginBridgeNonRtServerCvCount

  669.             {

  670.                 // uint/ins, uint/outs

  671.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);

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

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

  674.                 fShmNonRtServerControl.commitWrite();

  675.             }

  676. 

  677.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  678. 

  679.             // kPluginBridgeNonRtServerParameter*

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

  681.             {

  682.                 // uint/count

  683.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);

  684.                 fShmNonRtServerControl.writeUInt(count);

  685.                 fShmNonRtServerControl.commitWrite();

  686. 

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

  688.                 {

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

  690. 

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

  692.                         continue;

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

  694.                         continue;

  695. 

  696.                     // kPluginBridgeNonRtServerParameterData1

  697.                     {

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

  699.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);

  700.                         fShmNonRtServerControl.writeUInt(i);

  701.                         fShmNonRtServerControl.writeInt(paramData.rindex);

  702.                         fShmNonRtServerControl.writeUInt(paramData.type);

  703.                         fShmNonRtServerControl.writeUInt(paramData.hints);

  704.                         fShmNonRtServerControl.writeShort(paramData.midiCC);

  705.                         fShmNonRtServerControl.commitWrite();

  706.                     }

  707. 

  708.                     // kPluginBridgeNonRtServerParameterData2

  709.                     {

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

  711.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);

  712.                         fShmNonRtServerControl.writeUInt(i);

  713. 

  714.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  717.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  718.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  719. 

  720.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  723.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  724.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  725. 

  726.                         carla_zeroChars(bufStr, STR_MAX);

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

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

  729.                         fShmNonRtServerControl.writeUInt(bufStrSize);

  730.                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  731. 

  732.                         fShmNonRtServerControl.commitWrite();

  733.                     }

  734. 

  735.                     // kPluginBridgeNonRtServerParameterRanges

  736.                     {

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

  738. 

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

  740.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);

  741.                         fShmNonRtServerControl.writeUInt(i);

  742.                         fShmNonRtServerControl.writeFloat(paramRanges.def);

  743.                         fShmNonRtServerControl.writeFloat(paramRanges.min);

  744.                         fShmNonRtServerControl.writeFloat(paramRanges.max);

  745.                         fShmNonRtServerControl.writeFloat(paramRanges.step);

  746.                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);

  747.                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);

  748.                         fShmNonRtServerControl.commitWrite();

  749.                     }

  750. 

  751.                     // kPluginBridgeNonRtServerParameterValue2

  752.                     {

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

  754.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  755.                         fShmNonRtServerControl.writeUInt(i);

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

  757.                         fShmNonRtServerControl.commitWrite();

  758.                     }

  759. 

  760.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  761.                 }

  762.             }

  763. 

  764.             // kPluginBridgeNonRtServerProgram*

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

  766.             {

  767.                 // uint/count

  768.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);

  769.                 fShmNonRtServerControl.writeUInt(count);

  770.                 fShmNonRtServerControl.commitWrite();

  771. 

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

  773.                 {

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

  775.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);

  776.                     fShmNonRtServerControl.writeUInt(i);

  777. 

  778.                     carla_zeroChars(bufStr, STR_MAX);

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

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

  781.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  782.                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  783. 

  784.                     fShmNonRtServerControl.commitWrite();

  785.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  786.                 }

  787.             }

  788. 

  789.             // kPluginBridgeNonRtServerMidiProgram*

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

  791.             {

  792.                 // uint/count

  793.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);

  794.                 fShmNonRtServerControl.writeUInt(count);

  795.                 fShmNonRtServerControl.commitWrite();

  796. 

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

  798.                 {

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

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

  801. 

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

  803.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);

  804.                     fShmNonRtServerControl.writeUInt(i);

  805.                     fShmNonRtServerControl.writeUInt(mpData.bank);

  806.                     fShmNonRtServerControl.writeUInt(mpData.program);

  807. 

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

  809.                     fShmNonRtServerControl.writeUInt(bufStrSize);

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

  811. 

  812.                     fShmNonRtServerControl.commitWrite();

  813.                     fShmNonRtServerControl.waitIfDataIsReachingLimit();

  814.                 }

  815.             }

  816. 

  817.             // ready!

  818.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  819.             fShmNonRtServerControl.commitWrite();

  820.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  821. 

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

  823.             fLastPingTime = Time::currentTimeMillis();

  824.         }

  825. 

  826.         // send parameter outputs

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

  828.         {

  829.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  830. 

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

  832.             {

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

  834.                     continue;

  835. 

  836.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);

  837.                 fShmNonRtServerControl.writeUInt(i);

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

  839. 

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

  841.                 if (! fShmNonRtServerControl.commitWrite())

  842.                     break;

  843.             }

  844.         }

  845. 

  846.         CarlaEngine::idle();

  847. 

  848.         try {

  849.             handleNonRtData();

  850.         } CARLA_SAFE_EXCEPTION("handleNonRtData");

  851. 

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

  853.         {

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

  855.             threadShouldExit();

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

  857.         }

  858.     }

  859. 

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

  861.     {

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

  863. 

  864.         if (fLastPingTime < 0)

  865.             return;

  866. 

  867.         switch (action)

  868.         {

  869.         // uint/index float/value

  870.         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {

  871.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  872.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  873.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);

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

  875.             fShmNonRtServerControl.writeFloat(value3);

  876.             fShmNonRtServerControl.commitWrite();

  877.         }   break;

  878. 

  879.         // uint/index float/value

  880.         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {

  881.             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);

  882.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  883.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);

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

  885.             fShmNonRtServerControl.writeFloat(value3);

  886.             fShmNonRtServerControl.commitWrite();

  887.         }   break;

  888. 

  889.         // int/index

  890.         case ENGINE_CALLBACK_PROGRAM_CHANGED: {

  891.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  892.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  893.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);

  894.             fShmNonRtServerControl.writeInt(value1);

  895.             fShmNonRtServerControl.commitWrite();

  896.         }   break;

  897. 

  898.         // int/index

  899.         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {

  900.             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);

  901.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  902.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);

  903.             fShmNonRtServerControl.writeInt(value1);

  904.             fShmNonRtServerControl.commitWrite();

  905.         }   break;

  906. 

  907.         case ENGINE_CALLBACK_UI_STATE_CHANGED:

  908.             if (value1 != 1)

  909.             {

  910.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  911.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  912.                 fShmNonRtServerControl.commitWrite();

  913.             }

  914.             break;

  915. 

  916.         default:

  917.             break;

  918.         }

  919.     }

  920. 

  921.     // -------------------------------------------------------------------

  922. 

  923.     void clear() noexcept

  924.     {

  925.         fShmAudioPool.clear();

  926.         fShmRtClientControl.clear();

  927.         fShmNonRtClientControl.clear();

  928.         fShmNonRtServerControl.clear();

  929.     }

  930. 

  931.     void handleNonRtData()

  932.     {

  933.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  934.         {

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

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

  937. 

  938. #ifdef DEBUG

  939.             if (opcode != kPluginBridgeNonRtClientPing) {

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

  941.             }

  942. #endif

  943. 

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

  945.                 fLastPingTime = Time::currentTimeMillis();

  946. 

  947.             switch (opcode)

  948.             {

  949.             case kPluginBridgeNonRtClientNull:

  950.                 break;

  951. 

  952.             case kPluginBridgeNonRtClientPing: {

  953.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  954. 

  955.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  956.                 fShmNonRtServerControl.commitWrite();

  957.             }   break;

  958. 

  959.             case kPluginBridgeNonRtClientPingOnOff: {

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

  961. 

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

  963.             }   break;

  964. 

  965.             case kPluginBridgeNonRtClientActivate:

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

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

  968.                 break;

  969. 

  970.             case kPluginBridgeNonRtClientDeactivate:

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

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

  973.                 break;

  974. 

  975.             case kPluginBridgeNonRtClientSetBufferSize: {

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

  977.                 pData->bufferSize = bufferSize;

  978.                 bufferSizeChanged(bufferSize);

  979.                 break;

  980.             }

  981. 

  982.             case kPluginBridgeNonRtClientSetSampleRate: {

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

  984.                 pData->sampleRate = sampleRate;

  985.                 sampleRateChanged(sampleRate);

  986.                 break;

  987.             }

  988. 

  989.             case kPluginBridgeNonRtClientSetOffline:

  990.                 fIsOffline = true;

  991.                 offlineModeChanged(true);

  992.                 break;

  993. 

  994.             case kPluginBridgeNonRtClientSetOnline:

  995.                 fIsOffline = false;

  996.                 offlineModeChanged(false);

  997.                 break;

  998. 

  999.             case kPluginBridgeNonRtClientSetParameterValue: {

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

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

  1002. 

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

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

  1005.                 break;

  1006.             }

  1007. 

  1008.             case kPluginBridgeNonRtClientSetParameterMidiChannel: {

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

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

  1011. 

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

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

  1014.                 break;

  1015.             }

  1016. 

  1017.             case kPluginBridgeNonRtClientSetParameterMidiCC: {

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

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

  1020. 

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

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

  1023.                 break;

  1024.             }

  1025. 

  1026.             case kPluginBridgeNonRtClientSetProgram: {

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

  1028. 

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

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

  1031.                 break;

  1032.             }

  1033. 

  1034.             case kPluginBridgeNonRtClientSetMidiProgram: {

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

  1036. 

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

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

  1039.                 break;

  1040.             }

  1041. 

  1042.             case kPluginBridgeNonRtClientSetCustomData: {

  1043.                 // type

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

  1045.                 char typeStr[typeSize+1];

  1046.                 carla_zeroChars(typeStr, typeSize+1);

  1047.                 fShmNonRtClientControl.readCustomData(typeStr, typeSize);

  1048. 

  1049.                 // key

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

  1051.                 char keyStr[keySize+1];

  1052.                 carla_zeroChars(keyStr, keySize+1);

  1053.                 fShmNonRtClientControl.readCustomData(keyStr, keySize);

  1054. 

  1055.                 // value

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

  1057.                 char valueStr[valueSize+1];

  1058.                 carla_zeroChars(valueStr, valueSize+1);

  1059.                 fShmNonRtClientControl.readCustomData(valueStr, valueSize);

  1060. 

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

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

  1063.                 break;

  1064.             }

  1065. 

  1066.             case kPluginBridgeNonRtClientSetChunkDataFile: {

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

  1068.                 CARLA_SAFE_ASSERT_BREAK(size > 0);

  1069. 

  1070.                 char chunkFilePathTry[size+1];

  1071.                 carla_zeroChars(chunkFilePathTry, size+1);

  1072.                 fShmNonRtClientControl.readCustomData(chunkFilePathTry, size);

  1073. 

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

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

  1076. 

  1077.                 String chunkFilePath(chunkFilePathTry);

  1078. 

  1079. #ifdef CARLA_OS_WIN

  1080.                 // check if running under Wine

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

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

  1083. #endif

  1084. 

  1085.                 File chunkFile(chunkFilePath);

  1086.                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());

  1087. 

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

  1089.                 chunkFile.deleteFile();

  1090.                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());

  1091. 

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

  1093. 

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

  1095.                 break;

  1096.             }

  1097. 

  1098.             case kPluginBridgeNonRtClientSetCtrlChannel: {

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

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

  1101. 

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

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

  1104.                 break;

  1105.             }

  1106. 

  1107.             case kPluginBridgeNonRtClientSetOption: {

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

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

  1110. 

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

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

  1113.                 break;

  1114.             }

  1115. 

  1116.             case kPluginBridgeNonRtClientPrepareForSave: {

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

  1118. 

  1119.                 plugin->prepareForSave();

  1120. 

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

  1122.                 {

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

  1124. 

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

  1126.                         continue;

  1127. 

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

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

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

  1131. 

  1132.                     {

  1133.                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1134. 

  1135.                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);

  1136. 

  1137.                         fShmNonRtServerControl.writeUInt(typeLen);

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

  1139. 

  1140.                         fShmNonRtServerControl.writeUInt(keyLen);

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

  1142. 

  1143.                         fShmNonRtServerControl.writeUInt(valueLen);

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

  1145. 

  1146.                         fShmNonRtServerControl.commitWrite();

  1147.                         fShmNonRtServerControl.waitIfDataIsReachingLimit();

  1148.                     }

  1149.                 }

  1150. 

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

  1152.                 {

  1153.                     void* data = nullptr;

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

  1155.                     {

  1156.                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);

  1157. 

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

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

  1160. 

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

  1162. 

  1163.                         filePath += CARLA_OS_SEP_STR;

  1164.                         filePath += ".CarlaChunk_";

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

  1166. 

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

  1168.                         {

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

  1170. 

  1171.                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1172. 

  1173.                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);

  1174.                             fShmNonRtServerControl.writeUInt(ulength);

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

  1176.                             fShmNonRtServerControl.commitWrite();

  1177.                         }

  1178.                     }

  1179.                 }

  1180. 

  1181.                 {

  1182.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1183. 

  1184.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  1185.                     fShmNonRtServerControl.commitWrite();

  1186.                 }

  1187.                 break;

  1188.             }

  1189. 

  1190.             case kPluginBridgeNonRtClientShowUI:

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

  1192.                     plugin->showCustomUI(true);

  1193.                 break;

  1194. 

  1195.             case kPluginBridgeNonRtClientHideUI:

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

  1197.                     plugin->showCustomUI(false);

  1198.                 break;

  1199. 

  1200.             case kPluginBridgeNonRtClientUiParameterChange: {

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

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

  1203. 

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

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

  1206.                 break;

  1207.             }

  1208. 

  1209.             case kPluginBridgeNonRtClientUiProgramChange: {

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

  1211. 

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

  1213.                     plugin->uiProgramChange(index);

  1214.                 break;

  1215.             }

  1216. 

  1217.             case kPluginBridgeNonRtClientUiMidiProgramChange: {

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

  1219. 

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

  1221.                     plugin->uiMidiProgramChange(index);

  1222.                 break;

  1223.             }

  1224. 

  1225.             case kPluginBridgeNonRtClientUiNoteOn: {

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

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

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

  1229. 

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

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

  1232.                 break;

  1233.             }

  1234. 

  1235.             case kPluginBridgeNonRtClientUiNoteOff: {

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

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

  1238. 

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

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

  1241.                 break;

  1242.             }

  1243. 

  1244.             case kPluginBridgeNonRtClientQuit:

  1245.                 signalThreadShouldExit();

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

  1247.                 break;

  1248.             }

  1249.         }

  1250.     }

  1251. 

  1252.     // -------------------------------------------------------------------

  1253. 

  1254. protected:

  1255.     void run() override

  1256.     {

  1257.         bool quitReceived = false;

  1258. 

  1259.         for (; ! threadShouldExit();)

  1260.         {

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

  1262. 

  1263.             if (! helper.ok)

  1264.                 continue;

  1265. 

  1266.             for (; fShmRtClientControl.isDataAvailableForReading();)

  1267.             {

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

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

  1270. 

  1271. #ifdef DEBUG

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

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

  1274.                 }

  1275. #endif

  1276. 

  1277.                 switch (opcode)

  1278.                 {

  1279.                 case kPluginBridgeRtClientNull:

  1280.                     break;

  1281. 

  1282.                 case kPluginBridgeRtClientSetAudioPool: {

  1283.                     if (fShmAudioPool.data != nullptr)

  1284.                     {

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

  1286.                         fShmAudioPool.data = nullptr;

  1287.                     }

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

  1289.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

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

  1291.                     break;

  1292.                 }

  1293. 

  1294.                 case kPluginBridgeRtClientControlEventParameter: {

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

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

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

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

  1299. 

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

  1301.                     {

  1302.                         event->type    = kEngineEventTypeControl;

  1303.                         event->time    = time;

  1304.                         event->channel = channel;

  1305.                         event->ctrl.type  = kEngineControlEventTypeParameter;

  1306.                         event->ctrl.param = param;

  1307.                         event->ctrl.value = value;

  1308.                     }

  1309.                     break;

  1310.                 }

  1311. 

  1312.                 case kPluginBridgeRtClientControlEventMidiBank: {

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

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

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

  1316. 

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

  1318.                     {

  1319.                         event->type    = kEngineEventTypeControl;

  1320.                         event->time    = time;

  1321.                         event->channel = channel;

  1322.                         event->ctrl.type  = kEngineControlEventTypeMidiBank;

  1323.                         event->ctrl.param = index;

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

  1325.                     }

  1326.                     break;

  1327.                 }

  1328. 

  1329.                 case kPluginBridgeRtClientControlEventMidiProgram: {

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

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

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

  1333. 

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

  1335.                     {

  1336.                         event->type    = kEngineEventTypeControl;

  1337.                         event->time    = time;

  1338.                         event->channel = channel;

  1339.                         event->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1340.                         event->ctrl.param = index;

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

  1342.                     }

  1343.                     break;

  1344.                 }

  1345. 

  1346.                 case kPluginBridgeRtClientControlEventAllSoundOff: {

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

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

  1349. 

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

  1351.                     {

  1352.                         event->type    = kEngineEventTypeControl;

  1353.                         event->time    = time;

  1354.                         event->channel = channel;

  1355.                         event->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1356.                         event->ctrl.param = 0;

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

  1358.                     }

  1359.                 }   break;

  1360. 

  1361.                 case kPluginBridgeRtClientControlEventAllNotesOff: {

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

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

  1364. 

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

  1366.                     {

  1367.                         event->type    = kEngineEventTypeControl;

  1368.                         event->time    = time;

  1369.                         event->channel = channel;

  1370.                         event->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1371.                         event->ctrl.param = 0;

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

  1373.                     }

  1374.                 }   break;

  1375. 

  1376.                 case kPluginBridgeRtClientMidiEvent: {

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

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

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

  1380.                     CARLA_SAFE_ASSERT_BREAK(size > 0);

  1381. 

  1382.                     uint8_t data[size];

  1383. 

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

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

  1386. 

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

  1388.                     {

  1389.                         event->type    = kEngineEventTypeMidi;

  1390.                         event->time    = time;

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

  1392. 

  1393.                         event->midi.port = port;

  1394.                         event->midi.size = size;

  1395. 

  1396.                         if (size > EngineMidiEvent::kDataSize)

  1397.                         {

  1398.                             event->midi.dataExt = data;

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

  1400.                         }

  1401.                         else

  1402.                         {

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

  1404. 

  1405.                             uint8_t i=1;

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

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

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

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

  1410. 

  1411.                             event->midi.dataExt = nullptr;

  1412.                         }

  1413.                     }

  1414.                     break;

  1415.                 }

  1416. 

  1417.                 case kPluginBridgeRtClientProcess: {

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

  1419. 

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

  1421.                     {

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

  1423. 

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

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

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

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

  1428. 

  1429.                         const float* audioIn[audioInCount];

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

  1431.                         const float* cvIn[cvInCount];

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

  1433. 

  1434.                         float* fdata = fShmAudioPool.data;

  1435. 

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

  1437.                             audioIn[i] = fdata;

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

  1439.                             audioOut[i] = fdata;

  1440. 

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

  1442.                             cvIn[i] = fdata;

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

  1444.                             cvOut[i] = fdata;

  1445. 

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

  1447. 

  1448.                         timeInfo.playing = bridgeTimeInfo.playing;

  1449.                         timeInfo.frame   = bridgeTimeInfo.frame;

  1450.                         timeInfo.usecs   = bridgeTimeInfo.usecs;

  1451.                         timeInfo.valid   = bridgeTimeInfo.valid;

  1452. 

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

  1454.                         {

  1455.                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;

  1456.                             timeInfo.bbt.beat = bridgeTimeInfo.beat;

  1457.                             timeInfo.bbt.tick = bridgeTimeInfo.tick;

  1458. 

  1459.                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;

  1460.                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;

  1461. 

  1462.                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;

  1463.                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;

  1464.                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;

  1465.                         }

  1466. 

  1467.                         plugin->initBuffers();

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

  1469.                         plugin->unlock();

  1470.                     }

  1471. 

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

  1473.                     carla_zeroBytes(midiData, kBridgeRtClientDataMidiOutSize);

  1474.                     std::size_t curMidiDataPos = 0;

  1475. 

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

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

  1478. 

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

  1480.                     {

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

  1482.                         {

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

  1484. 

  1485.                             if (event.type == kEngineEventTypeNull)

  1486.                                 break;

  1487. 

  1488.                             if (event.type == kEngineEventTypeControl)

  1489.                             {

  1490.                                 uint8_t size;

  1491.                                 uint8_t data[3];

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

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

  1494. 

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

  1496.                                     break;

  1497. 

  1498.                                 // set size

  1499.                                 *midiData++ = size;

  1500. 

  1501.                                 // set time

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

  1503.                                 midiData = midiData + 4;

  1504. 

  1505.                                 // set data

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

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

  1508. 

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

  1510.                             }

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

  1512.                             {

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

  1514. 

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

  1516.                                     break;

  1517. 

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

  1519. 

  1520.                                 // set size

  1521.                                 *midiData++ = _midiEvent.size;

  1522. 

  1523.                                 // set time

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

  1525.                                 midiData = midiData + 4;

  1526. 

  1527.                                 // set data

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

  1529. 

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

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

  1532. 

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

  1534.                             }

  1535.                         }

  1536. 

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

  1538.                     }

  1539. 

  1540.                 }   break;

  1541. 

  1542.                 case kPluginBridgeRtClientQuit: {

  1543.                     quitReceived = true;

  1544.                     signalThreadShouldExit();

  1545.                 }   break;

  1546.                 }

  1547.             }

  1548.         }

  1549. 

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

  1551. 

  1552.         if (! quitReceived)

  1553.         {

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

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

  1556. 

  1557.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  1558.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  1559.             fShmNonRtServerControl.writeUInt(messageSize);

  1560.             fShmNonRtServerControl.writeCustomData(message, messageSize);

  1561.             fShmNonRtServerControl.commitWrite();

  1562.         }

  1563.     }

  1564. 

  1565.     // called from process thread above

  1566.     EngineEvent* getNextFreeInputEvent() const noexcept

  1567.     {

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

  1569.         {

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

  1571. 

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

  1573.                 return event;

  1574.         }

  1575.         return nullptr;

  1576.     }

  1577. 

  1578.     // -------------------------------------------------------------------

  1579. 

  1580. private:

  1581.     BridgeAudioPool          fShmAudioPool;

  1582.     BridgeRtClientControl    fShmRtClientControl;

  1583.     BridgeNonRtClientControl fShmNonRtClientControl;

  1584.     BridgeNonRtServerControl fShmNonRtServerControl;

  1585. 

  1586.     bool fIsOffline;

  1587.     bool fFirstIdle;

  1588.     int64_t fLastPingTime;

  1589. 

  1590.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)

  1591. };

  1592. 

  1593. // -----------------------------------------------------------------------

  1594. 

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

  1596. {

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

  1598. }

  1599. 

  1600. // -----------------------------------------------------------------------

  1601. 

  1602. #ifdef BRIDGE_PLUGIN

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

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

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

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

  1607. #endif

  1608. 

  1609. CARLA_BACKEND_END_NAMESPACE

  1610. 

  1611. // -----------------------------------------------------------------------

  1612. 

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

  1614. extern "C" __declspec (dllexport)

  1615. #else

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

  1617. #endif

  1618. void carla_register_native_plugin_carla();

  1619. void carla_register_native_plugin_carla(){}

  1620. 

  1621. // -----------------------------------------------------------------------