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.
2500 Commits
17 Branches
381MB
Tree: 339443b6a6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '339443b6a6'
${ noResults }
Carla/source/backend/plugin/CarlaPluginDSSI.cpp

2378 lines
84KB
Raw Blame History 

  1. /*

  2.  * Carla DSSI Plugin

  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. // TODO: set fUsesCustomData and latency index before init finishes

  19. // TODO: common laterncy code

  20. 

  21. #include "CarlaPluginInternal.hpp"

  22. #include "CarlaEngine.hpp"

  23. 

  24. #include "CarlaDssiUtils.hpp"

  25. #include "CarlaMathUtils.hpp"

  26. 

  27. CARLA_BACKEND_START_NAMESPACE

  28. 

  29. // -----------------------------------------------------

  30. 

  31. class CarlaPluginDSSI : public CarlaPlugin

  32. {

  33. public:

  34.     CarlaPluginDSSI(CarlaEngine* const engine, const uint id) noexcept

  35.         : CarlaPlugin(engine, id),

  36.           fHandle(nullptr),

  37.           fHandle2(nullptr),

  38.           fDescriptor(nullptr),

  39.           fDssiDescriptor(nullptr),

  40.           fUsesCustomData(false),

  41.           fUiFilename(nullptr),

  42.           fAudioInBuffers(nullptr),

  43.           fAudioOutBuffers(nullptr),

  44.           fParamBuffers(nullptr),

  45.           fLatencyChanged(false),

  46.           fLatencyIndex(-1),

  47.           leakDetector_CarlaPluginDSSI()

  48.     {

  49.         carla_debug("CarlaPluginDSSI::CarlaPluginDSSI(%p, %i)", engine, id);

  50. 

  51.         pData->osc.thread.setMode(CarlaPluginThread::PLUGIN_THREAD_DSSI_GUI);

  52.     }

  53. 

  54.     ~CarlaPluginDSSI() noexcept override

  55.     {

  56.         carla_debug("CarlaPluginDSSI::~CarlaPluginDSSI()");

  57. 

  58.         // close UI

  59.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  60.         {

  61.             showCustomUI(false);

  62. 

  63.             pData->osc.thread.stopThread(static_cast<int>(pData->engine->getOptions().uiBridgesTimeout * 2));

  64.         }

  65. 

  66.         pData->singleMutex.lock();

  67.         pData->masterMutex.lock();

  68. 

  69.         if (pData->client != nullptr && pData->client->isActive())

  70.             pData->client->deactivate();

  71. 

  72.         if (pData->active)

  73.         {

  74.             deactivate();

  75.             pData->active = false;

  76.         }

  77. 

  78.         if (fDescriptor != nullptr)

  79.         {

  80.             if (pData->name != nullptr && fDssiDescriptor != nullptr && fDssiDescriptor->run_synth == nullptr && fDssiDescriptor->run_multiple_synths != nullptr)

  81.                 removeUniqueMultiSynth(fDescriptor->Label);

  82. 

  83.             if (fDescriptor->cleanup != nullptr)

  84.             {

  85.                 if (fHandle != nullptr)

  86.                 {

  87.                     try {

  88.                         fDescriptor->cleanup(fHandle);

  89.                     } CARLA_SAFE_EXCEPTION("DSSI cleanup");

  90.                 }

  91. 

  92.                 if (fHandle2 != nullptr)

  93.                 {

  94.                     try {

  95.                         fDescriptor->cleanup(fHandle2);

  96.                     } CARLA_SAFE_EXCEPTION("DSSI cleanup #2");

  97.                 }

  98.             }

  99. 

  100.             fHandle  = nullptr;

  101.             fHandle2 = nullptr;

  102.             fDescriptor = nullptr;

  103.             fDssiDescriptor = nullptr;

  104.         }

  105. 

  106.         if (fUiFilename != nullptr)

  107.         {

  108.             delete[] fUiFilename;

  109.             fUiFilename = nullptr;

  110.         }

  111. 

  112.         clearBuffers();

  113.     }

  114. 

  115.     // -------------------------------------------------------------------

  116.     // Information (base)

  117. 

  118.     PluginType getType() const noexcept override

  119.     {

  120.         return PLUGIN_DSSI;

  121.     }

  122. 

  123.     PluginCategory getCategory() const noexcept override

  124.     {

  125.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr, PLUGIN_CATEGORY_NONE);

  126. 

  127.         if (pData->audioIn.count == 0 && pData->audioOut.count > 0 && (fDssiDescriptor->run_synth != nullptr || fDssiDescriptor->run_multiple_synths != nullptr))

  128.             return PLUGIN_CATEGORY_SYNTH;

  129. 

  130.         return CarlaPlugin::getCategory();

  131.     }

  132. 

  133.     int64_t getUniqueId() const noexcept override

  134.     {

  135.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0);

  136. 

  137.         return static_cast<int64_t>(fDescriptor->UniqueID);

  138.     }

  139. 

  140.     // -------------------------------------------------------------------

  141.     // Information (count)

  142. 

  143.     // nothing

  144. 

  145.     // -------------------------------------------------------------------

  146.     // Information (current data)

  147. 

  148.     std::size_t getChunkData(void** const dataPtr) noexcept override

  149.     {

  150.         CARLA_SAFE_ASSERT_RETURN(fUsesCustomData, 0);

  151.         CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS, 0);

  152.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr, 0);

  153.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor->get_custom_data != nullptr, 0);

  154.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, 0);

  155.         CARLA_SAFE_ASSERT_RETURN(fHandle2 == nullptr, 0);

  156.         CARLA_SAFE_ASSERT_RETURN(dataPtr != nullptr, 0);

  157. 

  158.         *dataPtr = nullptr;

  159. 

  160.         int ret = 0;

  161.         ulong dataSize = 0;

  162. 

  163.         try {

  164.             ret = fDssiDescriptor->get_custom_data(fHandle, dataPtr, &dataSize);

  165.         } CARLA_SAFE_EXCEPTION_RETURN("CarlaPluginDSSI::getChunkData", 0);

  166. 

  167.         return (ret != 0) ? dataSize : 0;

  168.     }

  169. 

  170.     // -------------------------------------------------------------------

  171.     // Information (per-plugin data)

  172. 

  173.     uint getOptionsAvailable() const noexcept override

  174.     {

  175.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr, 0x0);

  176. 

  177. #ifdef __USE_GNU

  178.         const bool isDssiVst(strcasestr(pData->filename, "dssi-vst") != nullptr);

  179. #else

  180.         const bool isDssiVst(std::strstr(pData->filename, "dssi-vst") != nullptr);

  181. #endif

  182. 

  183.         uint options = 0x0;

  184. 

  185.         if (fDssiDescriptor->get_program != nullptr && fDssiDescriptor->select_program != nullptr)

  186.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  187. 

  188.         if (! isDssiVst)

  189.         {

  190.             if (fLatencyIndex == -1)

  191.                 options |= PLUGIN_OPTION_FIXED_BUFFERS;

  192. 

  193.             if (pData->engine->getProccessMode() != ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  194.             {

  195.                 if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  196.                     options |= PLUGIN_OPTION_FORCE_STEREO;

  197.                 else if (pData->audioIn.count <= 1 && pData->audioOut.count <= 1 && (pData->audioIn.count != 0 || pData->audioOut.count != 0))

  198.                     options |= PLUGIN_OPTION_FORCE_STEREO;

  199.             }

  200.         }

  201. 

  202.         if (fUsesCustomData)

  203.             options |= PLUGIN_OPTION_USE_CHUNKS;

  204. 

  205.         if (fDssiDescriptor->run_synth != nullptr || fDssiDescriptor->run_multiple_synths != nullptr)

  206.         {

  207.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  208.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  209.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  210.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  211.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  212.         }

  213. 

  214.         return options;

  215.     }

  216. 

  217.     float getParameterValue(const uint32_t parameterId) const noexcept override

  218.     {

  219.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr, 0.0f);

  220.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);

  221. 

  222.         return fParamBuffers[parameterId];

  223.     }

  224. 

  225.     void getLabel(char* const strBuf) const noexcept override

  226.     {

  227.         CARLA_SAFE_ASSERT_RETURN(fDescriptor        != nullptr, nullStrBuf(strBuf));

  228.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Label != nullptr, nullStrBuf(strBuf));

  229. 

  230.         std::strncpy(strBuf, fDescriptor->Label, STR_MAX);

  231.     }

  232. 

  233.     void getMaker(char* const strBuf) const noexcept override

  234.     {

  235.         CARLA_SAFE_ASSERT_RETURN(fDescriptor        != nullptr, nullStrBuf(strBuf));

  236.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Maker != nullptr, nullStrBuf(strBuf));

  237. 

  238.         std::strncpy(strBuf, fDescriptor->Maker, STR_MAX);

  239.     }

  240. 

  241.     void getCopyright(char* const strBuf) const noexcept override

  242.     {

  243.         CARLA_SAFE_ASSERT_RETURN(fDescriptor            != nullptr, nullStrBuf(strBuf));

  244.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Copyright != nullptr, nullStrBuf(strBuf));

  245. 

  246.         std::strncpy(strBuf, fDescriptor->Copyright, STR_MAX);

  247.     }

  248. 

  249.     void getRealName(char* const strBuf) const noexcept override

  250.     {

  251.         CARLA_SAFE_ASSERT_RETURN(fDescriptor       != nullptr, nullStrBuf(strBuf));

  252.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Name != nullptr, nullStrBuf(strBuf));

  253. 

  254.         std::strncpy(strBuf, fDescriptor->Name, STR_MAX);

  255.     }

  256. 

  257.     void getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override

  258.     {

  259.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,           nullStrBuf(strBuf));

  260.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, nullStrBuf(strBuf));

  261. 

  262.         const int32_t rindex(pData->param.data[parameterId].rindex);

  263. 

  264.         CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fDescriptor->PortCount), nullStrBuf(strBuf));

  265.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames[rindex] != nullptr,             nullStrBuf(strBuf));

  266. 

  267.         if (getSeparatedParameterNameOrUnit(fDescriptor->PortNames[rindex], strBuf, true))

  268.             return;

  269. 

  270.         std::strncpy(strBuf, fDescriptor->PortNames[rindex], STR_MAX);

  271.     }

  272. 

  273.     void getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override

  274.     {

  275.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, nullStrBuf(strBuf));

  276. 

  277.         const int32_t rindex(pData->param.data[parameterId].rindex);

  278. 

  279.         CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fDescriptor->PortCount), nullStrBuf(strBuf));

  280. 

  281.         if (getSeparatedParameterNameOrUnit(fDescriptor->PortNames[rindex], strBuf, false))

  282.             return;

  283. 

  284.         nullStrBuf(strBuf);

  285.     }

  286. 

  287.     // -------------------------------------------------------------------

  288.     // Set data (state)

  289. 

  290.     // nothing

  291. 

  292.     // -------------------------------------------------------------------

  293.     // Set data (internal stuff)

  294. 

  295.     // nothing

  296. 

  297.     // -------------------------------------------------------------------

  298.     // Set data (plugin-specific stuff)

  299. 

  300.     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override

  301.     {

  302.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

  303.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  304. 

  305.         const float fixedValue(pData->param.getFixedValue(parameterId, value));

  306.         fParamBuffers[parameterId] = fixedValue;

  307. 

  308.         CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);

  309.     }

  310. 

  311.     void setCustomData(const char* const type, const char* const key, const char* const value, const bool sendGui) override

  312.     {

  313.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);

  314.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  315.         CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  316.         CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  317.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  318.         carla_debug("CarlaPluginDSSI::setCustomData(%s, %s, %s, %s)", type, key, value, bool2str(sendGui));

  319. 

  320.         if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) != 0)

  321.             return carla_stderr2("CarlaPluginDSSI::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is not string", type, key, value, bool2str(sendGui));

  322. 

  323.         if (fDssiDescriptor->configure != nullptr)

  324.         {

  325.             try {

  326.                 fDssiDescriptor->configure(fHandle, key, value);

  327.             } catch(...) {}

  328. 

  329.             if (fHandle2 != nullptr)

  330.             {

  331.                 try {

  332.                     fDssiDescriptor->configure(fHandle2, key, value);

  333.                 } catch(...) {}

  334.             }

  335.         }

  336. 

  337.         if (sendGui && pData->osc.data.target != nullptr)

  338.             osc_send_configure(pData->osc.data, key, value);

  339. 

  340.         if (std::strcmp(key, "reloadprograms") == 0 || std::strcmp(key, "load") == 0 || std::strncmp(key, "patches", 7) == 0)

  341.         {

  342.             const ScopedSingleProcessLocker spl(this, true);

  343.             reloadPrograms(false);

  344.         }

  345. 

  346.         CarlaPlugin::setCustomData(type, key, value, sendGui);

  347.     }

  348. 

  349.     void setChunkData(const void* const data, const std::size_t dataSize) override

  350.     {

  351.         CARLA_SAFE_ASSERT_RETURN(fUsesCustomData,);

  352.         CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS,);

  353.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);

  354.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor->set_custom_data != nullptr,);

  355.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  356.         CARLA_SAFE_ASSERT_RETURN(fHandle2 == nullptr,);

  357.         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  358.         CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

  359. 

  360.         {

  361.             const ScopedSingleProcessLocker spl(this, true);

  362. 

  363.             try {

  364.                 fDssiDescriptor->set_custom_data(fHandle, const_cast<void*>(data), static_cast<ulong>(dataSize));

  365.             } CARLA_SAFE_EXCEPTION("CarlaPluginDSSI::setChunkData");

  366.         }

  367. 

  368. #ifdef BUILD_BRIDGE

  369.         const bool sendOsc(false);

  370. #else

  371.         const bool sendOsc(pData->engine->isOscControlRegistered());

  372. #endif

  373.         pData->updateParameterValues(this, sendOsc, true, false);

  374.     }

  375. 

  376.     void setMidiProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override

  377.     {

  378.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);

  379.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor->select_program != nullptr,);

  380.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  381.         CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);

  382. 

  383.         if (index >= 0)

  384.         {

  385.             const uint32_t bank(pData->midiprog.data[index].bank);

  386.             const uint32_t program(pData->midiprog.data[index].program);

  387. 

  388.             const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));

  389. 

  390.             try {

  391.                 fDssiDescriptor->select_program(fHandle, bank, program);

  392.             } catch(...) {}

  393. 

  394.             if (fHandle2 != nullptr)

  395.             {

  396.                 try {

  397.                     fDssiDescriptor->select_program(fHandle2, bank, program);

  398.                 } catch(...) {}

  399.             }

  400.         }

  401. 

  402.         CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback);

  403.     }

  404. 

  405.     // -------------------------------------------------------------------

  406.     // Set ui stuff

  407. 

  408.     void showCustomUI(const bool yesNo) override

  409.     {

  410.         if (yesNo)

  411.         {

  412.             pData->osc.data.clear();

  413.             pData->osc.thread.startThread();

  414.         }

  415.         else

  416.         {

  417.             pData->transientTryCounter = 0;

  418. 

  419.             if (pData->osc.data.target != nullptr)

  420.             {

  421.                 osc_send_hide(pData->osc.data);

  422.                 osc_send_quit(pData->osc.data);

  423.                 pData->osc.data.clear();

  424.             }

  425. 

  426.             pData->osc.thread.stopThread(static_cast<int>(pData->engine->getOptions().uiBridgesTimeout * 2));

  427.         }

  428.     }

  429. 

  430.     void idle() override

  431.     {

  432.         if (fLatencyChanged && fLatencyIndex != -1)

  433.         {

  434.             fLatencyChanged = false;

  435. 

  436.             const int32_t latency(static_cast<int32_t>(fParamBuffers[fLatencyIndex]));

  437. 

  438.             if (latency >= 0)

  439.             {

  440.                 const uint32_t ulatency(static_cast<uint32_t>(latency));

  441. 

  442.                 if (pData->latency != ulatency)

  443.                 {

  444.                     carla_stdout("latency changed to %i", latency);

  445. 

  446.                     const ScopedSingleProcessLocker sspl(this, true);

  447. 

  448.                     pData->latency = ulatency;

  449.                     pData->client->setLatency(ulatency);

  450. #ifndef BUILD_BRIDGE

  451.                     pData->recreateLatencyBuffers();

  452. #endif

  453.                 }

  454.             }

  455.             else

  456.                 carla_safe_assert_int("latency >= 0", __FILE__, __LINE__, latency);

  457.         }

  458. 

  459.         CarlaPlugin::idle();

  460.     }

  461. 

  462.     // -------------------------------------------------------------------

  463.     // Plugin state

  464. 

  465.     void reload() override

  466.     {

  467.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);

  468.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  469.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);

  470.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  471.         carla_debug("CarlaPluginDSSI::reload() - start");

  472. 

  473.         const EngineProcessMode processMode(pData->engine->getProccessMode());

  474. 

  475.         // Safely disable plugin for reload

  476.         const ScopedDisabler sd(this);

  477. 

  478.         if (pData->active)

  479.             deactivate();

  480. 

  481.         clearBuffers();

  482. 

  483.         const float sampleRate(static_cast<float>(pData->engine->getSampleRate()));

  484.         const uint32_t portCount(getSafePortCount());

  485. 

  486.         uint32_t aIns, aOuts, mIns, params;

  487.         aIns = aOuts = mIns = params = 0;

  488. 

  489.         bool forcedStereoIn, forcedStereoOut;

  490.         forcedStereoIn = forcedStereoOut = false;

  491. 

  492.         bool needsCtrlIn, needsCtrlOut;

  493.         needsCtrlIn = needsCtrlOut = false;

  494. 

  495.         for (uint32_t i=0; i < portCount; ++i)

  496.         {

  497.             const LADSPA_PortDescriptor portType(fDescriptor->PortDescriptors[i]);

  498. 

  499.             if (LADSPA_IS_PORT_AUDIO(portType))

  500.             {

  501.                 if (LADSPA_IS_PORT_INPUT(portType))

  502.                     aIns += 1;

  503.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  504.                     aOuts += 1;

  505.             }

  506.             else if (LADSPA_IS_PORT_CONTROL(portType))

  507.                 params += 1;

  508.         }

  509. 

  510.         if ((pData->options & PLUGIN_OPTION_FORCE_STEREO) != 0 && (aIns == 1 || aOuts == 1))

  511.         {

  512.             if (fHandle2 == nullptr)

  513.             {

  514.                 try {

  515.                     fHandle2 = fDescriptor->instantiate(fDescriptor, static_cast<ulong>(sampleRate));

  516.                 } CARLA_SAFE_EXCEPTION("DSSI instantiate #2");

  517.             }

  518. 

  519.             if (fHandle2 != nullptr)

  520.             {

  521.                 if (aIns == 1)

  522.                 {

  523.                     aIns = 2;

  524.                     forcedStereoIn = true;

  525.                 }

  526. 

  527.                 if (aOuts == 1)

  528.                 {

  529.                     aOuts = 2;

  530.                     forcedStereoOut = true;

  531.                 }

  532.             }

  533.         }

  534. 

  535.         if (fDssiDescriptor->run_synth != nullptr || fDssiDescriptor->run_multiple_synths != nullptr)

  536.         {

  537.             mIns = 1;

  538.             needsCtrlIn = true;

  539.         }

  540. 

  541.         if (aIns > 0)

  542.         {

  543.             pData->audioIn.createNew(aIns);

  544.             fAudioInBuffers = new float*[aIns];

  545. 

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

  547.                 fAudioInBuffers[i] = nullptr;

  548.         }

  549. 

  550.         if (aOuts > 0)

  551.         {

  552.             pData->audioOut.createNew(aOuts);

  553.             fAudioOutBuffers = new float*[aOuts];

  554.             needsCtrlIn = true;

  555. 

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

  557.                 fAudioOutBuffers[i] = nullptr;

  558.         }

  559. 

  560.         if (params > 0)

  561.         {

  562.             pData->param.createNew(params, true);

  563. 

  564.             fParamBuffers = new float[params];

  565.             FloatVectorOperations::clear(fParamBuffers, static_cast<int>(params));

  566.         }

  567. 

  568.         const uint portNameSize(pData->engine->getMaxPortNameSize());

  569.         CarlaString portName;

  570. 

  571.         for (uint32_t i=0, iAudioIn=0, iAudioOut=0, iCtrl=0; i < portCount; ++i)

  572.         {

  573.             const LADSPA_PortDescriptor portType      = fDescriptor->PortDescriptors[i];

  574.             const LADSPA_PortRangeHint portRangeHints = fDescriptor->PortRangeHints[i];

  575. 

  576.             if (LADSPA_IS_PORT_AUDIO(portType))

  577.             {

  578.                 portName.clear();

  579. 

  580.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  581.                 {

  582.                     portName  = pData->name;

  583.                     portName += ":";

  584.                 }

  585. 

  586.                 if (fDescriptor->PortNames[i] != nullptr && fDescriptor->PortNames[i][0] != '\0')

  587.                 {

  588.                     portName += fDescriptor->PortNames[i];

  589.                 }

  590.                 else

  591.                 {

  592.                     if (LADSPA_IS_PORT_INPUT(portType))

  593.                     {

  594.                         if (aIns > 1)

  595.                         {

  596.                             portName += "audio-in_";

  597.                             portName += CarlaString(iAudioIn+1);

  598.                         }

  599.                         else

  600.                             portName += "audio-in";

  601.                     }

  602.                     else

  603.                     {

  604.                         if (aOuts > 1)

  605.                         {

  606.                             portName += "audio-out_";

  607.                             portName += CarlaString(iAudioOut+1);

  608.                         }

  609.                         else

  610.                             portName += "audio-out";

  611.                     }

  612.                 }

  613. 

  614.                 portName.truncate(portNameSize);

  615. 

  616.                 if (LADSPA_IS_PORT_INPUT(portType))

  617.                 {

  618.                     const uint32_t j = iAudioIn++;

  619.                     pData->audioIn.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true);

  620.                     pData->audioIn.ports[j].rindex = i;

  621. 

  622.                     if (forcedStereoIn)

  623.                     {

  624.                         portName += "_2";

  625.                         pData->audioIn.ports[1].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true);

  626.                         pData->audioIn.ports[1].rindex = i;

  627.                     }

  628.                 }

  629.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  630.                 {

  631.                     const uint32_t j = iAudioOut++;

  632.                     pData->audioOut.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false);

  633.                     pData->audioOut.ports[j].rindex = i;

  634. 

  635.                     if (forcedStereoOut)

  636.                     {

  637.                         portName += "_2";

  638.                         pData->audioOut.ports[1].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false);

  639.                         pData->audioOut.ports[1].rindex = i;

  640.                     }

  641.                 }

  642.                 else

  643.                     carla_stderr2("WARNING - Got a broken Port (Audio, but not input or output)");

  644.             }

  645.             else if (LADSPA_IS_PORT_CONTROL(portType))

  646.             {

  647.                 const uint32_t j = iCtrl++;

  648.                 pData->param.data[j].index  = static_cast<int32_t>(j);

  649.                 pData->param.data[j].rindex = static_cast<int32_t>(i);

  650. 

  651.                 const char* const paramName(fDescriptor->PortNames[i] != nullptr ? fDescriptor->PortNames[i] : "unknown");

  652. 

  653.                 float min, max, def, step, stepSmall, stepLarge;

  654. 

  655.                 // min value

  656.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  657.                     min = portRangeHints.LowerBound;

  658.                 else

  659.                     min = 0.0f;

  660. 

  661.                 // max value

  662.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  663.                     max = portRangeHints.UpperBound;

  664.                 else

  665.                     max = 1.0f;

  666. 

  667.                 if (min > max)

  668.                 {

  669.                     carla_stderr2("WARNING - Broken plugin parameter '%s': min > max", paramName);

  670.                     min = max - 0.1f;

  671.                 }

  672.                 else if (carla_compareFloats(min, max))

  673.                 {

  674.                     carla_stderr2("WARNING - Broken plugin parameter '%s': min == max", paramName);

  675.                     max = min + 0.1f;

  676.                 }

  677. 

  678.                 // default value

  679.                 def = get_default_ladspa_port_value(portRangeHints.HintDescriptor, min, max);

  680. 

  681.                 if (def < min)

  682.                     def = min;

  683.                 else if (def > max)

  684.                     def = max;

  685. 

  686.                 if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  687.                 {

  688.                     min *= sampleRate;

  689.                     max *= sampleRate;

  690.                     def *= sampleRate;

  691.                     pData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;

  692.                 }

  693. 

  694.                 if (LADSPA_IS_HINT_TOGGLED(portRangeHints.HintDescriptor))

  695.                 {

  696.                     step = max - min;

  697.                     stepSmall = step;

  698.                     stepLarge = step;

  699.                     pData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  700.                 }

  701.                 else if (LADSPA_IS_HINT_INTEGER(portRangeHints.HintDescriptor))

  702.                 {

  703.                     step = 1.0f;

  704.                     stepSmall = 1.0f;

  705.                     stepLarge = 10.0f;

  706.                     pData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  707.                 }

  708.                 else

  709.                 {

  710.                     const float range = max - min;

  711.                     step = range/100.0f;

  712.                     stepSmall = range/1000.0f;

  713.                     stepLarge = range/10.0f;

  714.                 }

  715. 

  716.                 if (LADSPA_IS_PORT_INPUT(portType))

  717.                 {

  718.                     pData->param.data[j].type   = PARAMETER_INPUT;

  719.                     pData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  720.                     pData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  721.                     needsCtrlIn = true;

  722. 

  723.                     // MIDI CC value

  724.                     if (fDssiDescriptor->get_midi_controller_for_port != nullptr)

  725.                     {

  726.                         int controller = fDssiDescriptor->get_midi_controller_for_port(fHandle, i);

  727.                         if (DSSI_CONTROLLER_IS_SET(controller) && DSSI_IS_CC(controller))

  728.                         {

  729.                             int16_t cc = DSSI_CC_NUMBER(controller);

  730.                             if (! MIDI_IS_CONTROL_BANK_SELECT(cc))

  731.                                 pData->param.data[j].midiCC = cc;

  732.                         }

  733.                     }

  734.                 }

  735.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  736.                 {

  737.                     pData->param.data[j].type = PARAMETER_OUTPUT;

  738. 

  739.                     if (std::strcmp(paramName, "latency") == 0 || std::strcmp(paramName, "_latency") == 0)

  740.                     {

  741.                         min = 0.0f;

  742.                         max = sampleRate;

  743.                         def = 0.0f;

  744.                         step = 1.0f;

  745.                         stepSmall = 1.0f;

  746.                         stepLarge = 1.0f;

  747.                         pData->param.special[j] = PARAMETER_SPECIAL_LATENCY;

  748.                         CARLA_SAFE_ASSERT(fLatencyIndex == -1);

  749.                         fLatencyIndex = static_cast<int32_t>(j);

  750.                     }

  751.                     else

  752.                     {

  753.                         pData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  754.                         pData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  755.                         needsCtrlOut = true;

  756.                     }

  757.                 }

  758.                 else

  759.                 {

  760.                     carla_stderr2("WARNING - Got a broken Port (Control, but not input or output)");

  761.                 }

  762. 

  763.                 // extra parameter hints

  764.                 if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor))

  765.                     pData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  766. 

  767.                 pData->param.ranges[j].min = min;

  768.                 pData->param.ranges[j].max = max;

  769.                 pData->param.ranges[j].def = def;

  770.                 pData->param.ranges[j].step = step;

  771.                 pData->param.ranges[j].stepSmall = stepSmall;

  772.                 pData->param.ranges[j].stepLarge = stepLarge;

  773. 

  774.                 // Start parameters in their default values

  775.                 fParamBuffers[j] = def;

  776. 

  777.                 try {

  778.                     fDescriptor->connect_port(fHandle, i, &fParamBuffers[j]);

  779.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port parameter");

  780. 

  781.                 if (fHandle2 != nullptr)

  782.                 {

  783.                     try {

  784.                         fDescriptor->connect_port(fHandle2, i, &fParamBuffers[j]);

  785.                     } CARLA_SAFE_EXCEPTION("DSSI connect_port parameter #2");

  786.                 }

  787.             }

  788.             else

  789.             {

  790.                 // Not Audio or Control

  791.                 carla_stderr2("ERROR - Got a broken Port (neither Audio or Control)");

  792. 

  793.                 try {

  794.                     fDescriptor->connect_port(fHandle, i, nullptr);

  795.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port null");

  796. 

  797.                 if (fHandle2 != nullptr)

  798.                 {

  799.                     try {

  800.                         fDescriptor->connect_port(fHandle2, i, nullptr);

  801.                     } CARLA_SAFE_EXCEPTION("DSSI connect_port null #2");

  802.                 }

  803.             }

  804.         }

  805. 

  806.         if (needsCtrlIn)

  807.         {

  808.             portName.clear();

  809. 

  810.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  811.             {

  812.                 portName  = pData->name;

  813.                 portName += ":";

  814.             }

  815. 

  816.             portName += "events-in";

  817.             portName.truncate(portNameSize);

  818. 

  819.             pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true);

  820.         }

  821. 

  822.         if (needsCtrlOut)

  823.         {

  824.             portName.clear();

  825. 

  826.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  827.             {

  828.                 portName  = pData->name;

  829.                 portName += ":";

  830.             }

  831. 

  832.             portName += "events-out";

  833.             portName.truncate(portNameSize);

  834. 

  835.             pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false);

  836.         }

  837. 

  838.         if (forcedStereoIn || forcedStereoOut)

  839.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  840.         else

  841.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  842. 

  843.         // plugin hints

  844.         pData->hints = 0x0;

  845. 

  846.         if (LADSPA_IS_HARD_RT_CAPABLE(fDescriptor->Properties))

  847.             pData->hints |= PLUGIN_IS_RTSAFE;

  848. 

  849.         if (fUiFilename != nullptr)

  850.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  851. 

  852. #ifndef BUILD_BRIDGE

  853.         if (aOuts > 0 && (aIns == aOuts || aIns == 1))

  854.             pData->hints |= PLUGIN_CAN_DRYWET;

  855. 

  856.         if (aOuts > 0)

  857.             pData->hints |= PLUGIN_CAN_VOLUME;

  858. 

  859.         if (aOuts >= 2 && aOuts % 2 == 0)

  860.             pData->hints |= PLUGIN_CAN_BALANCE;

  861. #endif

  862. 

  863.         // extra plugin hints

  864.         pData->extraHints = 0x0;

  865. 

  866.         if (mIns > 0)

  867.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  868. 

  869.         if (aIns <= 2 && aOuts <= 2 && (aIns == aOuts || aIns == 0 || aOuts == 0))

  870.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  871. 

  872.         // check latency

  873.         if (fLatencyIndex >= 0)

  874.         {

  875.             // we need to pre-run the plugin so it can update its latency control-port

  876. 

  877.             float tmpIn [(aIns > 0)  ? aIns  : 1][2];

  878.             float tmpOut[(aOuts > 0) ? aOuts : 1][2];

  879. 

  880.             for (uint32_t j=0; j < aIns; ++j)

  881.             {

  882.                 tmpIn[j][0] = 0.0f;

  883.                 tmpIn[j][1] = 0.0f;

  884. 

  885.                 try {

  886.                     fDescriptor->connect_port(fHandle, pData->audioIn.ports[j].rindex, tmpIn[j]);

  887.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port latency input");

  888.             }

  889. 

  890.             for (uint32_t j=0; j < aOuts; ++j)

  891.             {

  892.                 tmpOut[j][0] = 0.0f;

  893.                 tmpOut[j][1] = 0.0f;

  894. 

  895.                 try {

  896.                     fDescriptor->connect_port(fHandle, pData->audioOut.ports[j].rindex, tmpOut[j]);

  897.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port latency output");

  898.             }

  899. 

  900.             if (fDescriptor->activate != nullptr)

  901.             {

  902.                 try {

  903.                     fDescriptor->activate(fHandle);

  904.                 } CARLA_SAFE_EXCEPTION("DSSI latency activate");

  905.             }

  906. 

  907.             try {

  908.                 fDescriptor->run(fHandle, 2);

  909.             } CARLA_SAFE_EXCEPTION("DSSI latency run");

  910. 

  911.             if (fDescriptor->deactivate != nullptr)

  912.             {

  913.                 try {

  914.                     fDescriptor->deactivate(fHandle);

  915.                 } CARLA_SAFE_EXCEPTION("DSSI latency deactivate");

  916.             }

  917. 

  918.             const int32_t latency(static_cast<int32_t>(fParamBuffers[fLatencyIndex]));

  919. 

  920.             if (latency >= 0)

  921.             {

  922.                 const uint32_t ulatency(static_cast<uint32_t>(latency));

  923. 

  924.                 if (pData->latency != ulatency)

  925.                 {

  926.                     carla_stdout("latency = %i", latency);

  927. 

  928.                     pData->latency = ulatency;

  929.                     pData->client->setLatency(ulatency);

  930. #ifndef BUILD_BRIDGE

  931.                     pData->recreateLatencyBuffers();

  932. #endif

  933.                 }

  934.             }

  935.             else

  936.                 carla_safe_assert_int("latency >= 0", __FILE__, __LINE__, latency);

  937. 

  938.             fLatencyChanged = false;

  939.         }

  940. 

  941.         bufferSizeChanged(pData->engine->getBufferSize());

  942.         reloadPrograms(true);

  943. 

  944.         if (pData->active)

  945.             activate();

  946. 

  947.         carla_debug("CarlaPluginDSSI::reload() - end");

  948.     }

  949. 

  950.     void reloadPrograms(const bool doInit) override

  951.     {

  952.         carla_debug("CarlaPluginDSSI::reloadPrograms(%s)", bool2str(doInit));

  953.         const uint32_t oldCount = pData->midiprog.count;

  954.         const int32_t  current  = pData->midiprog.current;

  955. 

  956.         // Delete old programs

  957.         pData->midiprog.clear();

  958. 

  959.         // Query new programs

  960.         uint32_t newCount = 0;

  961.         if (fDssiDescriptor->get_program != nullptr && fDssiDescriptor->select_program != nullptr)

  962.         {

  963.             for (; fDssiDescriptor->get_program(fHandle, newCount) != nullptr;)

  964.                 ++newCount;

  965.         }

  966. 

  967.         if (newCount > 0)

  968.         {

  969.             pData->midiprog.createNew(newCount);

  970. 

  971.             // Update data

  972.             for (uint32_t i=0; i < newCount; ++i)

  973.             {

  974.                 const DSSI_Program_Descriptor* const pdesc(fDssiDescriptor->get_program(fHandle, i));

  975.                 CARLA_SAFE_ASSERT_CONTINUE(pdesc != nullptr);

  976.                 CARLA_SAFE_ASSERT(pdesc->Name != nullptr);

  977. 

  978.                 pData->midiprog.data[i].bank    = static_cast<uint32_t>(pdesc->Bank);

  979.                 pData->midiprog.data[i].program = static_cast<uint32_t>(pdesc->Program);

  980.                 pData->midiprog.data[i].name    = carla_strdup(pdesc->Name);

  981.             }

  982.         }

  983. 

  984. #ifndef BUILD_BRIDGE

  985.         // Update OSC Names

  986.         if (pData->engine->isOscControlRegistered())

  987.         {

  988.             pData->engine->oscSend_control_set_midi_program_count(pData->id, newCount);

  989. 

  990.             for (uint32_t i=0; i < newCount; ++i)

  991.                 pData->engine->oscSend_control_set_midi_program_data(pData->id, i, pData->midiprog.data[i].bank, pData->midiprog.data[i].program, pData->midiprog.data[i].name);

  992.         }

  993. #endif

  994. 

  995.         if (doInit)

  996.         {

  997.             if (newCount > 0)

  998.                 setMidiProgram(0, false, false, false);

  999.         }

  1000.         else

  1001.         {

  1002.             // Check if current program is invalid

  1003.             bool programChanged = false;

  1004. 

  1005.             if (newCount == oldCount+1)

  1006.             {

  1007.                 // one midi program added, probably created by user

  1008.                 pData->midiprog.current = static_cast<int32_t>(oldCount);

  1009.                 programChanged = true;

  1010.             }

  1011.             else if (current < 0 && newCount > 0)

  1012.             {

  1013.                 // programs exist now, but not before

  1014.                 pData->midiprog.current = 0;

  1015.                 programChanged = true;

  1016.             }

  1017.             else if (current >= 0 && newCount == 0)

  1018.             {

  1019.                 // programs existed before, but not anymore

  1020.                 pData->midiprog.current = -1;

  1021.                 programChanged = true;

  1022.             }

  1023.             else if (current >= static_cast<int32_t>(newCount))

  1024.             {

  1025.                 // current midi program > count

  1026.                 pData->midiprog.current = 0;

  1027.                 programChanged = true;

  1028.             }

  1029.             else

  1030.             {

  1031.                 // no change

  1032.                 pData->midiprog.current = current;

  1033.             }

  1034. 

  1035.             if (programChanged)

  1036.                 setMidiProgram(pData->midiprog.current, true, true, true);

  1037. 

  1038.             pData->engine->callback(ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0.0f, nullptr);

  1039.         }

  1040.     }

  1041. 

  1042.     // -------------------------------------------------------------------

  1043.     // Plugin processing

  1044. 

  1045.     void activate() noexcept override

  1046.     {

  1047.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1048.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1049. 

  1050.         if (fDescriptor->activate != nullptr)

  1051.         {

  1052.             try {

  1053.                 fDescriptor->activate(fHandle);

  1054.             } CARLA_SAFE_EXCEPTION("DSSI activate");

  1055. 

  1056.             if (fHandle2 != nullptr)

  1057.             {

  1058.                 try {

  1059.                     fDescriptor->activate(fHandle2);

  1060.                 } CARLA_SAFE_EXCEPTION("DSSI activate #2");

  1061.             }

  1062.         }

  1063.     }

  1064. 

  1065.     void deactivate() noexcept override

  1066.     {

  1067.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1068.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1069. 

  1070.         if (fDescriptor->deactivate != nullptr)

  1071.         {

  1072.             try {

  1073.                 fDescriptor->deactivate(fHandle);

  1074.             } CARLA_SAFE_EXCEPTION("DSSI deactivate");

  1075. 

  1076.             if (fHandle2 != nullptr)

  1077.             {

  1078.                 try {

  1079.                     fDescriptor->deactivate(fHandle2);

  1080.                 } CARLA_SAFE_EXCEPTION("DSSI deactivate #2");

  1081.             }

  1082.         }

  1083.     }

  1084. 

  1085.     void process(const float** const audioIn, float** const audioOut, const float** const cvIn, float** const cvOut, const uint32_t frames) override

  1086.     {

  1087.         // --------------------------------------------------------------------------------------------------------

  1088.         // Check if active

  1089. 

  1090.         if (! pData->active)

  1091.         {

  1092.             // disable any output sound

  1093.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1094.                 FloatVectorOperations::clear(audioOut[i], static_cast<int>(frames));

  1095.             for (uint32_t i=0; i < pData->cvOut.count; ++i)

  1096.                 FloatVectorOperations::clear(cvOut[i], static_cast<int>(frames));

  1097.             return;

  1098.         }

  1099. 

  1100.         ulong midiEventCount = 0;

  1101.         carla_zeroStruct<snd_seq_event_t>(fMidiEvents, kPluginMaxMidiEvents);

  1102. 

  1103.         // --------------------------------------------------------------------------------------------------------

  1104.         // Check if needs reset

  1105. 

  1106.         if (pData->needsReset)

  1107.         {

  1108.             if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1109.             {

  1110.                 midiEventCount = MAX_MIDI_CHANNELS*2;

  1111. 

  1112.                 for (uchar i=0, k=MAX_MIDI_CHANNELS; i < MAX_MIDI_CHANNELS; ++i)

  1113.                 {

  1114.                     fMidiEvents[i].type = SND_SEQ_EVENT_CONTROLLER;

  1115.                     fMidiEvents[i].data.control.channel = i;

  1116.                     fMidiEvents[i].data.control.param   = MIDI_CONTROL_ALL_NOTES_OFF;

  1117. 

  1118.                     fMidiEvents[k+i].type = SND_SEQ_EVENT_CONTROLLER;

  1119.                     fMidiEvents[k+i].data.control.channel = i;

  1120.                     fMidiEvents[k+i].data.control.param   = MIDI_CONTROL_ALL_SOUND_OFF;

  1121.                 }

  1122.             }

  1123.             else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  1124.             {

  1125.                 midiEventCount = MAX_MIDI_NOTE;

  1126. 

  1127.                 for (uchar i=0; i < MAX_MIDI_NOTE; ++i)

  1128.                 {

  1129.                     fMidiEvents[i].type = SND_SEQ_EVENT_NOTEOFF;

  1130.                     fMidiEvents[i].data.note.channel = static_cast<uchar>(pData->ctrlChannel);

  1131.                     fMidiEvents[i].data.note.note    = i;

  1132.                 }

  1133.             }

  1134. 

  1135. #ifndef BUILD_BRIDGE

  1136.             if (pData->latency > 0)

  1137.             {

  1138.                 for (uint32_t i=0; i < pData->audioIn.count; ++i)

  1139.                     FloatVectorOperations::clear(pData->latencyBuffers[i], static_cast<int>(pData->latency));

  1140.             }

  1141. #endif

  1142. 

  1143.             pData->needsReset = false;

  1144.         }

  1145. 

  1146.         // --------------------------------------------------------------------------------------------------------

  1147.         // Event Input and Processing

  1148. 

  1149.         if (pData->event.portIn != nullptr)

  1150.         {

  1151.             // ----------------------------------------------------------------------------------------------------

  1152.             // MIDI Input (External)

  1153. 

  1154.             if (pData->extNotes.mutex.tryLock())

  1155.             {

  1156.                 ExternalMidiNote note = { 0, 0, 0 };

  1157. 

  1158.                 for (; midiEventCount < kPluginMaxMidiEvents && ! pData->extNotes.data.isEmpty();)

  1159.                 {

  1160.                     note = pData->extNotes.data.getFirst(note, true);

  1161. 

  1162.                     CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);

  1163. 

  1164.                     snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);

  1165. 

  1166.                     seqEvent.type               = (note.velo > 0) ? SND_SEQ_EVENT_NOTEON : SND_SEQ_EVENT_NOTEOFF;

  1167.                     seqEvent.data.note.channel  = static_cast<uchar>(note.channel);

  1168.                     seqEvent.data.note.note     = note.note;

  1169.                     seqEvent.data.note.velocity = note.velo;

  1170.                 }

  1171. 

  1172.                 pData->extNotes.mutex.unlock();

  1173. 

  1174.             } // End of MIDI Input (External)

  1175. 

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

  1177.             // Event Input (System)

  1178. 

  1179. #ifndef BUILD_BRIDGE

  1180.             bool       allNotesOffSent  = false;

  1181. #endif

  1182.             const bool isSampleAccurate = (pData->options & PLUGIN_OPTION_FIXED_BUFFERS) == 0;

  1183. 

  1184.             uint32_t startTime  = 0;

  1185.             uint32_t timeOffset = 0;

  1186.             uint32_t nextBankId;

  1187. 

  1188.             if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)

  1189.                 nextBankId = pData->midiprog.data[pData->midiprog.current].bank;

  1190.             else

  1191.                 nextBankId = 0;

  1192. 

  1193.             for (uint32_t i=0, numEvents=pData->event.portIn->getEventCount(); i < numEvents; ++i)

  1194.             {

  1195.                 const EngineEvent& event(pData->event.portIn->getEvent(i));

  1196. 

  1197.                 if (event.time >= frames)

  1198.                     continue;

  1199. 

  1200.                 CARLA_ASSERT_INT2(event.time >= timeOffset, event.time, timeOffset);

  1201. 

  1202.                 if (isSampleAccurate && event.time > timeOffset)

  1203.                 {

  1204.                     if (processSingle(audioIn, audioOut, cvIn, cvOut, event.time - timeOffset, timeOffset, midiEventCount))

  1205.                     {

  1206.                         startTime  = 0;

  1207.                         timeOffset = event.time;

  1208.                         midiEventCount = 0;

  1209. 

  1210.                         if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)

  1211.                             nextBankId = pData->midiprog.data[pData->midiprog.current].bank;

  1212.                         else

  1213.                             nextBankId = 0;

  1214.                     }

  1215.                     else

  1216.                         startTime += timeOffset;

  1217.                 }

  1218. 

  1219.                 switch (event.type)

  1220.                 {

  1221.                 case kEngineEventTypeNull:

  1222.                     break;

  1223. 

  1224.                 case kEngineEventTypeControl: {

  1225.                     const EngineControlEvent& ctrlEvent(event.ctrl);

  1226. 

  1227.                     switch (ctrlEvent.type)

  1228.                     {

  1229.                     case kEngineControlEventTypeNull:

  1230.                         break;

  1231. 

  1232.                     case kEngineControlEventTypeParameter: {

  1233. #ifndef BUILD_BRIDGE

  1234.                         // Control backend stuff

  1235.                         if (event.channel == pData->ctrlChannel)

  1236.                         {

  1237.                             float value;

  1238. 

  1239.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)

  1240.                             {

  1241.                                 value = ctrlEvent.value;

  1242.                                 setDryWet(value, false, false);

  1243.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  1244.                                 break;

  1245.                             }

  1246. 

  1247.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)

  1248.                             {

  1249.                                 value = ctrlEvent.value*127.0f/100.0f;

  1250.                                 setVolume(value, false, false);

  1251.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  1252.                                 break;

  1253.                             }

  1254. 

  1255.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)

  1256.                             {

  1257.                                 float left, right;

  1258.                                 value = ctrlEvent.value/0.5f - 1.0f;

  1259. 

  1260.                                 if (value < 0.0f)

  1261.                                 {

  1262.                                     left  = -1.0f;

  1263.                                     right = (value*2.0f)+1.0f;

  1264.                                 }

  1265.                                 else if (value > 0.0f)

  1266.                                 {

  1267.                                     left  = (value*2.0f)-1.0f;

  1268.                                     right = 1.0f;

  1269.                                 }

  1270.                                 else

  1271.                                 {

  1272.                                     left  = -1.0f;

  1273.                                     right = 1.0f;

  1274.                                 }

  1275. 

  1276.                                 setBalanceLeft(left, false, false);

  1277.                                 setBalanceRight(right, false, false);

  1278.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  1279.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  1280.                                 break;

  1281.                             }

  1282.                         }

  1283. #endif

  1284.                         // Control plugin parameters

  1285.                         uint32_t k;

  1286.                         for (k=0; k < pData->param.count; ++k)

  1287.                         {

  1288.                             if (pData->param.data[k].midiChannel != event.channel)

  1289.                                 continue;

  1290.                             if (pData->param.data[k].midiCC != ctrlEvent.param)

  1291.                                 continue;

  1292.                             if (pData->param.data[k].type != PARAMETER_INPUT)

  1293.                                 continue;

  1294.                             if ((pData->param.data[k].hints & PARAMETER_IS_AUTOMABLE) == 0)

  1295.                                 continue;

  1296. 

  1297.                             float value;

  1298. 

  1299.                             if (pData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  1300.                             {

  1301.                                 value = (ctrlEvent.value < 0.5f) ? pData->param.ranges[k].min : pData->param.ranges[k].max;

  1302.                             }

  1303.                             else

  1304.                             {

  1305.                                 value = pData->param.ranges[k].getUnnormalizedValue(ctrlEvent.value);

  1306. 

  1307.                                 if (pData->param.data[k].hints & PARAMETER_IS_INTEGER)

  1308.                                     value = std::rint(value);

  1309.                             }

  1310. 

  1311.                             setParameterValue(k, value, false, false, false);

  1312.                             pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  1313.                             break;

  1314.                         }

  1315. 

  1316.                         // check if event is already handled

  1317.                         if (k != pData->param.count)

  1318.                             break;

  1319. 

  1320.                         if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_CONTROL)

  1321.                         {

  1322.                             if (midiEventCount >= kPluginMaxMidiEvents)

  1323.                                 continue;

  1324. 

  1325.                             snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);

  1326. 

  1327.                             seqEvent.time.tick = isSampleAccurate ? startTime : event.time;

  1328. 

  1329.                             seqEvent.type = SND_SEQ_EVENT_CONTROLLER;

  1330.                             seqEvent.data.control.channel = event.channel;

  1331.                             seqEvent.data.control.param   = ctrlEvent.param;

  1332.                             seqEvent.data.control.value   = int8_t(ctrlEvent.value*127.0f);

  1333.                         }

  1334.                         break;

  1335.                     } // case kEngineControlEventTypeParameter

  1336. 

  1337.                     case kEngineControlEventTypeMidiBank:

  1338.                         if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1339.                             nextBankId = ctrlEvent.param;

  1340.                         break;

  1341. 

  1342.                     case kEngineControlEventTypeMidiProgram:

  1343.                         if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1344.                         {

  1345.                             const uint32_t nextProgramId = ctrlEvent.param;

  1346. 

  1347.                             for (uint32_t k=0; k < pData->midiprog.count; ++k)

  1348.                             {

  1349.                                 if (pData->midiprog.data[k].bank == nextBankId && pData->midiprog.data[k].program == nextProgramId)

  1350.                                 {

  1351.                                     const int32_t index(static_cast<int32_t>(k));

  1352.                                     setMidiProgram(index, false, false, false);

  1353.                                     pData->postponeRtEvent(kPluginPostRtEventMidiProgramChange, index, 0, 0.0f);

  1354.                                     break;

  1355.                                 }

  1356.                             }

  1357.                         }

  1358.                         break;

  1359. 

  1360.                     case kEngineControlEventTypeAllSoundOff:

  1361.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1362.                         {

  1363.                             if (midiEventCount >= kPluginMaxMidiEvents)

  1364.                                 continue;

  1365. 

  1366.                             snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);

  1367. 

  1368.                             seqEvent.time.tick = isSampleAccurate ? startTime : event.time;

  1369. 

  1370.                             seqEvent.type = SND_SEQ_EVENT_CONTROLLER;

  1371.                             seqEvent.data.control.channel = event.channel;

  1372.                             seqEvent.data.control.param   = MIDI_CONTROL_ALL_SOUND_OFF;

  1373.                         }

  1374.                         break;

  1375. 

  1376.                     case kEngineControlEventTypeAllNotesOff:

  1377.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1378.                         {

  1379. #ifndef BUILD_BRIDGE

  1380.                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)

  1381.                             {

  1382.                                 allNotesOffSent = true;

  1383.                                 sendMidiAllNotesOffToCallback();

  1384.                             }

  1385. #endif

  1386. 

  1387.                             if (midiEventCount >= kPluginMaxMidiEvents)

  1388.                                 continue;

  1389. 

  1390.                             snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);

  1391. 

  1392.                             seqEvent.time.tick = isSampleAccurate ? startTime : event.time;

  1393. 

  1394.                             seqEvent.type = SND_SEQ_EVENT_CONTROLLER;

  1395.                             seqEvent.data.control.channel = event.channel;

  1396.                             seqEvent.data.control.param   = MIDI_CONTROL_ALL_NOTES_OFF;

  1397.                         }

  1398.                         break;

  1399.                     } // switch (ctrlEvent.type)

  1400.                     break;

  1401.                 } // case kEngineEventTypeControl

  1402. 

  1403.                 case kEngineEventTypeMidi: {

  1404.                     if (midiEventCount >= kPluginMaxMidiEvents)

  1405.                         continue;

  1406. 

  1407.                     const EngineMidiEvent& midiEvent(event.midi);

  1408. 

  1409.                     if (midiEvent.size > EngineMidiEvent::kDataSize)

  1410.                         continue;

  1411. 

  1412.                     uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiEvent.data));

  1413. 

  1414.                     // Fix bad note-off (per DSSI spec)

  1415.                     if (status == MIDI_STATUS_NOTE_ON && midiEvent.data[2] == 0)

  1416.                         status = MIDI_STATUS_NOTE_OFF;

  1417. 

  1418.                     snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);

  1419. 

  1420.                     seqEvent.time.tick = isSampleAccurate ? startTime : event.time;

  1421. 

  1422.                     switch (status)

  1423.                     {

  1424.                     case MIDI_STATUS_NOTE_OFF: {

  1425.                         const uint8_t note = midiEvent.data[1];

  1426. 

  1427.                         seqEvent.type = SND_SEQ_EVENT_NOTEOFF;

  1428.                         seqEvent.data.note.channel = event.channel;

  1429.                         seqEvent.data.note.note    = note;

  1430. 

  1431.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff, event.channel, note, 0.0f);

  1432.                         break;

  1433.                     }

  1434. 

  1435.                     case MIDI_STATUS_NOTE_ON: {

  1436.                         const uint8_t note = midiEvent.data[1];

  1437.                         const uint8_t velo = midiEvent.data[2];

  1438. 

  1439.                         seqEvent.type = SND_SEQ_EVENT_NOTEON;

  1440.                         seqEvent.data.note.channel  = event.channel;

  1441.                         seqEvent.data.note.note     = note;

  1442.                         seqEvent.data.note.velocity = velo;

  1443. 

  1444.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn, event.channel, note, velo);

  1445.                         break;

  1446.                     }

  1447. 

  1448.                     case MIDI_STATUS_POLYPHONIC_AFTERTOUCH:

  1449.                         if (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH)

  1450.                         {

  1451.                             const uint8_t note     = midiEvent.data[1];

  1452.                             const uint8_t pressure = midiEvent.data[2];

  1453. 

  1454.                             seqEvent.type = SND_SEQ_EVENT_KEYPRESS;

  1455.                             seqEvent.data.note.channel  = event.channel;

  1456.                             seqEvent.data.note.note     = note;

  1457.                             seqEvent.data.note.velocity = pressure;

  1458.                         }

  1459.                         break;

  1460. 

  1461.                     case MIDI_STATUS_CONTROL_CHANGE:

  1462.                         if (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES)

  1463.                         {

  1464.                             const uint8_t control = midiEvent.data[1];

  1465.                             const uint8_t value   = midiEvent.data[2];

  1466. 

  1467.                             seqEvent.type = SND_SEQ_EVENT_CONTROLLER;

  1468.                             seqEvent.data.control.channel = event.channel;

  1469.                             seqEvent.data.control.param   = control;

  1470.                             seqEvent.data.control.value   = value;

  1471.                         }

  1472.                         break;

  1473. 

  1474.                     case MIDI_STATUS_CHANNEL_PRESSURE:

  1475.                         if (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE)

  1476.                         {

  1477.                             const uint8_t pressure = midiEvent.data[1];

  1478. 

  1479.                             seqEvent.type = SND_SEQ_EVENT_CHANPRESS;

  1480.                             seqEvent.data.control.channel = event.channel;

  1481.                             seqEvent.data.control.value   = pressure;

  1482.                         }

  1483.                         break;

  1484. 

  1485.                     case MIDI_STATUS_PITCH_WHEEL_CONTROL:

  1486.                         if (pData->options & PLUGIN_OPTION_SEND_PITCHBEND)

  1487.                         {

  1488.                             const uint8_t lsb = midiEvent.data[1];

  1489.                             const uint8_t msb = midiEvent.data[2];

  1490. 

  1491.                             seqEvent.type = SND_SEQ_EVENT_PITCHBEND;

  1492.                             seqEvent.data.control.channel = event.channel;

  1493.                             seqEvent.data.control.value   = ((msb << 7) | lsb) - 8192;

  1494.                         }

  1495.                         break;

  1496. 

  1497.                     default:

  1498.                         --midiEventCount;

  1499.                         break;

  1500.                     } // switch (status)

  1501.                 } break;

  1502.                 } // switch (event.type)

  1503.             }

  1504. 

  1505.             pData->postRtEvents.trySplice();

  1506. 

  1507.             if (frames > timeOffset)

  1508.                 processSingle(audioIn, audioOut, cvIn, cvOut, frames - timeOffset, timeOffset, midiEventCount);

  1509. 

  1510.         } // End of Event Input and Processing

  1511. 

  1512.         // --------------------------------------------------------------------------------------------------------

  1513.         // Plugin processing (no events)

  1514. 

  1515.         else

  1516.         {

  1517.             processSingle(audioIn, audioOut, cvIn, cvOut, frames, 0, midiEventCount);

  1518. 

  1519.         } // End of Plugin processing (no events)

  1520. 

  1521. #ifndef BUILD_BRIDGE

  1522.         // --------------------------------------------------------------------------------------------------------

  1523.         // Latency, save values for next callback

  1524. 

  1525.         if (fLatencyIndex != -1)

  1526.         {

  1527.             if (pData->latency != static_cast<uint32_t>(fParamBuffers[fLatencyIndex]))

  1528.             {

  1529.                 fLatencyChanged = true;

  1530.             }

  1531.             else if (pData->latency > 0)

  1532.             {

  1533.                 if (pData->latency <= frames)

  1534.                 {

  1535.                     for (uint32_t i=0; i < pData->audioIn.count; ++i)

  1536.                         FloatVectorOperations::copy(pData->latencyBuffers[i], audioIn[i]+(frames-pData->latency), static_cast<int>(pData->latency));

  1537.                 }

  1538.                 else

  1539.                 {

  1540.                     for (uint32_t i=0, j, k; i < pData->audioIn.count; ++i)

  1541.                     {

  1542.                         for (k=0; k < pData->latency-frames; ++k)

  1543.                             pData->latencyBuffers[i][k] = pData->latencyBuffers[i][k+frames];

  1544.                         for (j=0; k < pData->latency; ++j, ++k)

  1545.                             pData->latencyBuffers[i][k] = audioIn[i][j];

  1546.                     }

  1547.                 }

  1548.             }

  1549.         }

  1550. 

  1551.         // --------------------------------------------------------------------------------------------------------

  1552.         // Control Output

  1553. 

  1554.         if (pData->event.portOut != nullptr)

  1555.         {

  1556.             uint8_t  channel;

  1557.             uint16_t param;

  1558.             float    value;

  1559. 

  1560.             for (uint32_t k=0; k < pData->param.count; ++k)

  1561.             {

  1562.                 if (pData->param.data[k].type != PARAMETER_OUTPUT)

  1563.                     continue;

  1564. 

  1565.                 pData->param.ranges[k].fixValue(fParamBuffers[k]);

  1566. 

  1567.                 if (pData->param.data[k].midiCC > 0)

  1568.                 {

  1569.                     channel = pData->param.data[k].midiChannel;

  1570.                     param   = static_cast<uint16_t>(pData->param.data[k].midiCC);

  1571.                     value   = pData->param.ranges[k].getNormalizedValue(fParamBuffers[k]);

  1572.                     pData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value);

  1573.                 }

  1574.             }

  1575.         } // End of Control Output

  1576. #endif

  1577.     }

  1578. 

  1579.     bool processSingle(const float** const audioIn, float** const audioOut, const float** const cvIn, float** const cvOut, const uint32_t frames, const uint32_t timeOffset, const ulong midiEventCount)

  1580.     {

  1581.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1582. 

  1583.         if (pData->audioIn.count > 0)

  1584.         {

  1585.             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);

  1586.         }

  1587.         if (pData->audioOut.count > 0)

  1588.         {

  1589.             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);

  1590.         }

  1591.         if (pData->cvIn.count > 0)

  1592.         {

  1593.             CARLA_SAFE_ASSERT_RETURN(cvIn != nullptr, false);

  1594.         }

  1595.         if (pData->cvOut.count > 0)

  1596.         {

  1597.             CARLA_SAFE_ASSERT_RETURN(cvOut != nullptr, false);

  1598.         }

  1599. 

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

  1601.         // Try lock, silence otherwise

  1602. 

  1603.         if (pData->engine->isOffline())

  1604.         {

  1605.             pData->singleMutex.lock();

  1606.         }

  1607.         else if (! pData->singleMutex.tryLock())

  1608.         {

  1609.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1610.             {

  1611.                 for (uint32_t k=0; k < frames; ++k)

  1612.                     audioOut[i][k+timeOffset] = 0.0f;

  1613.             }

  1614.             for (uint32_t i=0; i < pData->cvOut.count; ++i)

  1615.             {

  1616.                 for (uint32_t k=0; k < frames; ++k)

  1617.                     cvOut[i][k+timeOffset] = 0.0f;

  1618.             }

  1619. 

  1620.             return false;

  1621.         }

  1622. 

  1623.         // --------------------------------------------------------------------------------------------------------

  1624.         // Set audio buffers

  1625. 

  1626.         for (uint32_t i=0; i < pData->audioIn.count; ++i)

  1627.             FloatVectorOperations::copy(fAudioInBuffers[i], audioIn[i]+timeOffset, static_cast<int>(frames));

  1628. 

  1629.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1630.             FloatVectorOperations::clear(fAudioOutBuffers[i], static_cast<int>(frames));

  1631. 

  1632. #if 0

  1633.         // --------------------------------------------------------------------------------------------------------

  1634.         // Set CV buffers

  1635. 

  1636.         for (uint32_t i=0; i < pData->cvIn.count; ++i)

  1637.             FloatVectorOperations::copy(fCvInBuffers[i], cvIn[i]+timeOffset, static_cast<int>(frames));

  1638. 

  1639.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  1640.             FloatVectorOperations::clear(fCvOutBuffers[i], static_cast<int>(frames));

  1641. #endif

  1642. 

  1643.         // --------------------------------------------------------------------------------------------------------

  1644.         // Run plugin

  1645. 

  1646.         // TODO - try catch

  1647. 

  1648.         if (fDssiDescriptor->run_synth != nullptr)

  1649.         {

  1650.             fDssiDescriptor->run_synth(fHandle, frames, fMidiEvents, midiEventCount);

  1651. 

  1652.             if (fHandle2 != nullptr)

  1653.                 fDssiDescriptor->run_synth(fHandle2, frames, fMidiEvents, midiEventCount);

  1654.         }

  1655.         else if (fDssiDescriptor->run_multiple_synths != nullptr)

  1656.         {

  1657.             ulong instances = (fHandle2 != nullptr) ? 2 : 1;

  1658.             LADSPA_Handle handlePtr[2] = { fHandle, fHandle2 };

  1659.             snd_seq_event_t* midiEventsPtr[2] = { fMidiEvents, fMidiEvents };

  1660.             ulong midiEventCountPtr[2] = { midiEventCount, midiEventCount };

  1661.             fDssiDescriptor->run_multiple_synths(instances, handlePtr, frames, midiEventsPtr, midiEventCountPtr);

  1662.         }

  1663.         else

  1664.         {

  1665.             fDescriptor->run(fHandle, frames);

  1666. 

  1667.             if (fHandle2 != nullptr)

  1668.                 fDescriptor->run(fHandle2, frames);

  1669.         }

  1670. 

  1671. #ifndef BUILD_BRIDGE

  1672.         // --------------------------------------------------------------------------------------------------------

  1673.         // Post-processing (dry/wet, volume and balance)

  1674. 

  1675.         {

  1676.             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && ! carla_compareFloats(pData->postProc.dryWet, 1.0f);

  1677.             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_compareFloats(pData->postProc.balanceLeft, -1.0f) && carla_compareFloats(pData->postProc.balanceRight, 1.0f));

  1678.             const bool isMono    = (pData->audioIn.count == 1);

  1679. 

  1680.             bool isPair;

  1681.             float bufValue, oldBufLeft[doBalance ? frames : 1];

  1682. 

  1683.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1684.             {

  1685.                 // Dry/Wet

  1686.                 if (doDryWet)

  1687.                 {

  1688.                     for (uint32_t k=0; k < frames; ++k)

  1689.                     {

  1690.                         if (k < pData->latency)

  1691.                             bufValue = pData->latencyBuffers[isMono ? 0 : i][k];

  1692.                         else if (pData->latency < frames)

  1693.                             bufValue = fAudioInBuffers[isMono ? 0 : i][k-pData->latency];

  1694.                         else

  1695.                             bufValue = fAudioInBuffers[isMono ? 0 : i][k];

  1696. 

  1697.                         fAudioOutBuffers[i][k] = (fAudioOutBuffers[i][k] * pData->postProc.dryWet) + (bufValue * (1.0f - pData->postProc.dryWet));

  1698.                     }

  1699.                 }

  1700. 

  1701.                 // Balance

  1702.                 if (doBalance)

  1703.                 {

  1704.                     isPair = (i % 2 == 0);

  1705. 

  1706.                     if (isPair)

  1707.                     {

  1708.                         CARLA_ASSERT(i+1 < pData->audioOut.count);

  1709.                         FloatVectorOperations::copy(oldBufLeft, fAudioOutBuffers[i], static_cast<int>(frames));

  1710.                     }

  1711. 

  1712.                     float balRangeL = (pData->postProc.balanceLeft  + 1.0f)/2.0f;

  1713.                     float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;

  1714. 

  1715.                     for (uint32_t k=0; k < frames; ++k)

  1716.                     {

  1717.                         if (isPair)

  1718.                         {

  1719.                             // left

  1720.                             fAudioOutBuffers[i][k]  = oldBufLeft[k]            * (1.0f - balRangeL);

  1721.                             fAudioOutBuffers[i][k] += fAudioOutBuffers[i+1][k] * (1.0f - balRangeR);

  1722.                         }

  1723.                         else

  1724.                         {

  1725.                             // right

  1726.                             fAudioOutBuffers[i][k]  = fAudioOutBuffers[i][k] * balRangeR;

  1727.                             fAudioOutBuffers[i][k] += oldBufLeft[k]          * balRangeL;

  1728.                         }

  1729.                     }

  1730.                 }

  1731. 

  1732.                 // Volume (and buffer copy)

  1733.                 {

  1734.                     for (uint32_t k=0; k < frames; ++k)

  1735.                         audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k] * pData->postProc.volume;

  1736.                 }

  1737.             }

  1738. 

  1739.         } // End of Post-processing

  1740. 

  1741. #else // BUILD_BRIDGE

  1742.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1743.         {

  1744.             for (uint32_t k=0; k < frames; ++k)

  1745.                 audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k];

  1746.         }

  1747. #endif

  1748. 

  1749. #if 0

  1750.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  1751.         {

  1752.             for (uint32_t k=0; k < frames; ++k)

  1753.                 cvOut[i][k+timeOffset] = fCvOutBuffers[i][k];

  1754.         }

  1755. #endif

  1756. 

  1757.         // --------------------------------------------------------------------------------------------------------

  1758. 

  1759.         pData->singleMutex.unlock();

  1760.         return true;

  1761.     }

  1762. 

  1763.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1764.     {

  1765.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  1766.         carla_debug("CarlaPluginDSSI::bufferSizeChanged(%i) - start", newBufferSize);

  1767. 

  1768.         for (uint32_t i=0; i < pData->audioIn.count; ++i)

  1769.         {

  1770.             if (fAudioInBuffers[i] != nullptr)

  1771.                 delete[] fAudioInBuffers[i];

  1772.             fAudioInBuffers[i] = new float[newBufferSize];

  1773.         }

  1774. 

  1775.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1776.         {

  1777.             if (fAudioOutBuffers[i] != nullptr)

  1778.                 delete[] fAudioOutBuffers[i];

  1779.             fAudioOutBuffers[i] = new float[newBufferSize];

  1780.         }

  1781. 

  1782.         if (fHandle2 == nullptr)

  1783.         {

  1784.             for (uint32_t i=0; i < pData->audioIn.count; ++i)

  1785.             {

  1786.                 CARLA_ASSERT(fAudioInBuffers[i] != nullptr);

  1787. 

  1788.                 try {

  1789.                     fDescriptor->connect_port(fHandle, pData->audioIn.ports[i].rindex, fAudioInBuffers[i]);

  1790.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port audio input");

  1791.             }

  1792. 

  1793.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1794.             {

  1795.                 CARLA_ASSERT(fAudioOutBuffers[i] != nullptr);

  1796. 

  1797.                 try {

  1798.                     fDescriptor->connect_port(fHandle, pData->audioOut.ports[i].rindex, fAudioOutBuffers[i]);

  1799.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port audio output");

  1800.             }

  1801.         }

  1802.         else

  1803.         {

  1804.             if (pData->audioIn.count > 0)

  1805.             {

  1806.                 CARLA_ASSERT(pData->audioIn.count == 2);

  1807.                 CARLA_ASSERT(fAudioInBuffers[0] != nullptr);

  1808.                 CARLA_ASSERT(fAudioInBuffers[1] != nullptr);

  1809. 

  1810.                 try {

  1811.                     fDescriptor->connect_port(fHandle, pData->audioIn.ports[0].rindex, fAudioInBuffers[0]);

  1812.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port audio input #1");

  1813. 

  1814.                 try {

  1815.                     fDescriptor->connect_port(fHandle2, pData->audioIn.ports[1].rindex, fAudioInBuffers[1]);

  1816.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port audio input #2");

  1817.             }

  1818. 

  1819.             if (pData->audioOut.count > 0)

  1820.             {

  1821.                 CARLA_ASSERT(pData->audioOut.count == 2);

  1822.                 CARLA_ASSERT(fAudioOutBuffers[0] != nullptr);

  1823.                 CARLA_ASSERT(fAudioOutBuffers[1] != nullptr);

  1824. 

  1825.                 try {

  1826.                     fDescriptor->connect_port(fHandle, pData->audioOut.ports[0].rindex, fAudioOutBuffers[0]);

  1827.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port audio output #1");

  1828. 

  1829.                 try {

  1830.                     fDescriptor->connect_port(fHandle2, pData->audioOut.ports[1].rindex, fAudioOutBuffers[1]);

  1831.                 } CARLA_SAFE_EXCEPTION("DSSI connect_port audio output #2");

  1832.             }

  1833.         }

  1834. 

  1835.         carla_debug("CarlaPluginDSSI::bufferSizeChanged(%i) - end", newBufferSize);

  1836.     }

  1837. 

  1838.     void sampleRateChanged(const double newSampleRate) override

  1839.     {

  1840.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  1841.         carla_debug("CarlaPluginDSSI::sampleRateChanged(%g) - start", newSampleRate);

  1842. 

  1843.         // TODO

  1844.         (void)newSampleRate;

  1845. 

  1846.         carla_debug("CarlaPluginDSSI::sampleRateChanged(%g) - end", newSampleRate);

  1847.     }

  1848. 

  1849.     // -------------------------------------------------------------------

  1850.     // Plugin buffers

  1851. 

  1852.     void clearBuffers() noexcept override

  1853.     {

  1854.         carla_debug("CarlaPluginDSSI::clearBuffers() - start");

  1855. 

  1856.         if (fAudioInBuffers != nullptr)

  1857.         {

  1858.             for (uint32_t i=0; i < pData->audioIn.count; ++i)

  1859.             {

  1860.                 if (fAudioInBuffers[i] != nullptr)

  1861.                 {

  1862.                     delete[] fAudioInBuffers[i];

  1863.                     fAudioInBuffers[i] = nullptr;

  1864.                 }

  1865.             }

  1866. 

  1867.             delete[] fAudioInBuffers;

  1868.             fAudioInBuffers = nullptr;

  1869.         }

  1870. 

  1871.         if (fAudioOutBuffers != nullptr)

  1872.         {

  1873.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1874.             {

  1875.                 if (fAudioOutBuffers[i] != nullptr)

  1876.                 {

  1877.                     delete[] fAudioOutBuffers[i];

  1878.                     fAudioOutBuffers[i] = nullptr;

  1879.                 }

  1880.             }

  1881. 

  1882.             delete[] fAudioOutBuffers;

  1883.             fAudioOutBuffers = nullptr;

  1884.         }

  1885. 

  1886.         if (fParamBuffers != nullptr)

  1887.         {

  1888.             delete[] fParamBuffers;

  1889.             fParamBuffers = nullptr;

  1890.         }

  1891. 

  1892.         CarlaPlugin::clearBuffers();

  1893. 

  1894.         carla_debug("CarlaPluginDSSI::clearBuffers() - end");

  1895.     }

  1896. 

  1897.     // -------------------------------------------------------------------

  1898.     // OSC stuff

  1899. 

  1900.     void updateOscURL() override

  1901.     {

  1902.         // DSSI does not support this

  1903.         if (! pData->osc.thread.isThreadRunning())

  1904.             return;

  1905. 

  1906.         showCustomUI(false);

  1907.         //showCustomUI(true);

  1908.     }

  1909. 

  1910.     // -------------------------------------------------------------------

  1911.     // Post-poned UI Stuff

  1912. 

  1913.     void uiParameterChange(const uint32_t index, const float value) noexcept override

  1914.     {

  1915.         CARLA_SAFE_ASSERT_RETURN(index < pData->param.count,);

  1916. 

  1917.         if (pData->osc.data.target == nullptr)

  1918.             return;

  1919. 

  1920.         osc_send_control(pData->osc.data, pData->param.data[index].rindex, value);

  1921.     }

  1922. 

  1923.     void uiMidiProgramChange(const uint32_t index) noexcept override

  1924.     {

  1925.         CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);

  1926. 

  1927.         if (pData->osc.data.target == nullptr)

  1928.             return;

  1929. 

  1930.         osc_send_program(pData->osc.data, pData->midiprog.data[index].bank, pData->midiprog.data[index].program);

  1931.     }

  1932. 

  1933.     void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) noexcept override

  1934.     {

  1935.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1936.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  1937.         CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);

  1938. 

  1939.         if (pData->osc.data.target == nullptr)

  1940.             return;

  1941. 

  1942. #if 0

  1943.         uint8_t midiData[4];

  1944.         midiData[0] = 0;

  1945.         midiData[1] = uint8_t(MIDI_STATUS_NOTE_ON | (channel & MIDI_CHANNEL_BIT));

  1946.         midiData[2] = note;

  1947.         midiData[3] = velo;

  1948. 

  1949.         osc_send_midi(pData->osc.data, midiData);

  1950. #endif

  1951.     }

  1952. 

  1953.     void uiNoteOff(const uint8_t channel, const uint8_t note) noexcept override

  1954.     {

  1955.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1956.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  1957. 

  1958.         if (pData->osc.data.target == nullptr)

  1959.             return;

  1960. 

  1961. #if 0

  1962.         uint8_t midiData[4];

  1963.         midiData[0] = 0;

  1964.         midiData[1] = uint8_t(MIDI_STATUS_NOTE_ON | (channel & MIDI_CHANNEL_BIT));

  1965.         midiData[2] = note;

  1966.         midiData[3] = 0;

  1967. 

  1968.         osc_send_midi(pData->osc.data, midiData);

  1969. #endif

  1970.     }

  1971. 

  1972.     // -------------------------------------------------------------------

  1973. 

  1974.     void* getNativeHandle() const noexcept override

  1975.     {

  1976.         return fHandle;

  1977.     }

  1978. 

  1979.     const void* getNativeDescriptor() const noexcept override

  1980.     {

  1981.         return fDssiDescriptor;

  1982.     }

  1983. 

  1984.     const void* getExtraStuff() const noexcept override

  1985.     {

  1986.         return fUiFilename;

  1987.     }

  1988. 

  1989.     // -------------------------------------------------------------------

  1990. 

  1991.     bool init(const char* const filename, const char* const name, const char* const label)

  1992.     {

  1993.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  1994. 

  1995.         // ---------------------------------------------------------------

  1996.         // first checks

  1997. 

  1998.         if (pData->client != nullptr)

  1999.         {

  2000.             pData->engine->setLastError("Plugin client is already registered");

  2001.             return false;

  2002.         }

  2003. 

  2004.         if (filename == nullptr || filename[0] == '\0')

  2005.         {

  2006.             pData->engine->setLastError("null filename");

  2007.             return false;

  2008.         }

  2009. 

  2010.         if (label == nullptr || label[0] == '\0')

  2011.         {

  2012.             pData->engine->setLastError("null label");

  2013.             return false;

  2014.         }

  2015. 

  2016.         // ---------------------------------------------------------------

  2017.         // open DLL

  2018. 

  2019.         if (! pData->libOpen(filename))

  2020.         {

  2021.             pData->engine->setLastError(pData->libError(filename));

  2022.             return false;

  2023.         }

  2024. 

  2025.         // ---------------------------------------------------------------

  2026.         // get DLL main entry

  2027. 

  2028.         const DSSI_Descriptor_Function descFn = pData->libSymbol<DSSI_Descriptor_Function>("dssi_descriptor");

  2029. 

  2030.         if (descFn == nullptr)

  2031.         {

  2032.             pData->engine->setLastError("Could not find the DSSI Descriptor in the plugin library");

  2033.             return false;

  2034.         }

  2035. 

  2036.         // ---------------------------------------------------------------

  2037.         // get descriptor that matches label

  2038. 

  2039.         ulong i = 0;

  2040. 

  2041.         for (;;)

  2042.         {

  2043.             try {

  2044.                 fDssiDescriptor = descFn(i++);

  2045.             }

  2046.             catch(...) {

  2047.                 carla_stderr2("Caught exception when trying to get LADSPA descriptor");

  2048.                 fDescriptor     = nullptr;

  2049.                 fDssiDescriptor = nullptr;

  2050.                 break;

  2051.             }

  2052. 

  2053.             if (fDssiDescriptor == nullptr)

  2054.                 break;

  2055. 

  2056.             fDescriptor = fDssiDescriptor->LADSPA_Plugin;

  2057. 

  2058.             if (fDescriptor == nullptr)

  2059.             {

  2060.                 carla_stderr2("WARNING - Missing LADSPA interface, will not use this plugin");

  2061.                 fDssiDescriptor = nullptr;

  2062.                 break;

  2063.             }

  2064.             if (fDescriptor->Label == nullptr || fDescriptor->Label[0] == '\0')

  2065.             {

  2066.                 carla_stderr2("WARNING - Got an invalid label, will not use this plugin");

  2067.                 fDescriptor     = nullptr;

  2068.                 fDssiDescriptor = nullptr;

  2069.                 break;

  2070.             }

  2071.             if (fDescriptor->run == nullptr)

  2072.             {

  2073.                 carla_stderr2("WARNING - Plugin has no run, cannot use it");

  2074.                 fDescriptor     = nullptr;

  2075.                 fDssiDescriptor = nullptr;

  2076.                 break;

  2077.             }

  2078. 

  2079.             if (std::strcmp(fDescriptor->Label, label) == 0)

  2080.                 break;

  2081.         }

  2082. 

  2083.         if (fDescriptor == nullptr || fDssiDescriptor == nullptr)

  2084.         {

  2085.             pData->engine->setLastError("Could not find the requested plugin label in the plugin library");

  2086.             return false;

  2087.         }

  2088. 

  2089.         // ---------------------------------------------------------------

  2090.         // check if uses global instance

  2091. 

  2092.         if (fDssiDescriptor->run_synth == nullptr && fDssiDescriptor->run_multiple_synths != nullptr)

  2093.         {

  2094.             if (! addUniqueMultiSynth(fDescriptor->Label))

  2095.             {

  2096.                 pData->engine->setLastError("This plugin uses a global instance and can't be used more than once safely");

  2097.                 return false;

  2098.             }

  2099.         }

  2100. 

  2101.         // ---------------------------------------------------------------

  2102.         // get info

  2103. 

  2104.         if (name != nullptr && name[0] != '\0')

  2105.             pData->name = pData->engine->getUniquePluginName(name);

  2106.         else if (fDescriptor->Name != nullptr && fDescriptor->Name[0] != '\0')

  2107.             pData->name = pData->engine->getUniquePluginName(fDescriptor->Name);

  2108.         else

  2109.             pData->name = pData->engine->getUniquePluginName(fDescriptor->Label);

  2110. 

  2111.         pData->filename = carla_strdup(filename);

  2112. 

  2113.         // ---------------------------------------------------------------

  2114.         // register client

  2115. 

  2116.         pData->client = pData->engine->addClient(this);

  2117. 

  2118.         if (pData->client == nullptr || ! pData->client->isOk())

  2119.         {

  2120.             pData->engine->setLastError("Failed to register plugin client");

  2121.             return false;

  2122.         }

  2123. 

  2124.         // ---------------------------------------------------------------

  2125.         // initialize plugin

  2126. 

  2127.         try {

  2128.             fHandle = fDescriptor->instantiate(fDescriptor, (ulong)pData->engine->getSampleRate());

  2129.         } CARLA_SAFE_EXCEPTION("DSSI instantiate");

  2130. 

  2131.         if (fHandle == nullptr)

  2132.         {

  2133.             pData->engine->setLastError("Plugin failed to initialize");

  2134.             return false;

  2135.         }

  2136. 

  2137.         // ---------------------------------------------------------------

  2138.         // check for custom data extension

  2139. 

  2140.         if (fDssiDescriptor->configure != nullptr)

  2141.         {

  2142.             if (char* const error = fDssiDescriptor->configure(fHandle, DSSI_CUSTOMDATA_EXTENSION_KEY, ""))

  2143.             {

  2144.                 if (std::strcmp(error, "true") == 0 && fDssiDescriptor->get_custom_data != nullptr && fDssiDescriptor->set_custom_data != nullptr)

  2145.                     fUsesCustomData = true;

  2146. 

  2147.                 std::free(error);

  2148.             }

  2149.         }

  2150. 

  2151.         // ---------------------------------------------------------------

  2152.         // gui stuff

  2153. 

  2154.         if (const char* const guiFilename = find_dssi_ui(filename, fDescriptor->Label))

  2155.         {

  2156.             pData->osc.thread.setOscData(guiFilename, fDescriptor->Label);

  2157.             fUiFilename = guiFilename;

  2158.         }

  2159. 

  2160.         // ---------------------------------------------------------------

  2161.         // set default options

  2162. 

  2163. #ifdef __USE_GNU

  2164.         const bool isDssiVst(strcasestr(pData->filename, "dssi-vst") != nullptr);

  2165. #else

  2166.         const bool isDssiVst(std::strstr(pData->filename, "dssi-vst") != nullptr);

  2167. #endif

  2168. 

  2169.         pData->options = 0x0;

  2170. 

  2171.         if (fLatencyIndex >= 0 || isDssiVst)

  2172.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  2173. 

  2174.         if (pData->engine->getOptions().forceStereo)

  2175.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  2176. 

  2177.         if (fUsesCustomData)

  2178.             pData->options |= PLUGIN_OPTION_USE_CHUNKS;

  2179. 

  2180.         if (fDssiDescriptor->get_program != nullptr && fDssiDescriptor->select_program != nullptr)

  2181.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2182. 

  2183.         if (fDssiDescriptor->run_synth != nullptr || fDssiDescriptor->run_multiple_synths != nullptr)

  2184.         {

  2185.             pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2186.             pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2187.             pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  2188.             pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2189. 

  2190.             if (fDssiDescriptor->run_synth == nullptr)

  2191.                 carla_stderr("WARNING: Plugin can ONLY use run_multiple_synths!");

  2192.         }

  2193. 

  2194.         return true;

  2195.     }

  2196. 

  2197.     // -------------------------------------------------------------------

  2198. 

  2199. private:

  2200.     LADSPA_Handle fHandle;

  2201.     LADSPA_Handle fHandle2;

  2202.     const LADSPA_Descriptor* fDescriptor;

  2203.     const DSSI_Descriptor*   fDssiDescriptor;

  2204. 

  2205.     bool fUsesCustomData;

  2206.     const char* fUiFilename;

  2207. 

  2208.     float** fAudioInBuffers;

  2209.     float** fAudioOutBuffers;

  2210.     float*  fParamBuffers;

  2211. 

  2212.     bool    fLatencyChanged;

  2213.     int32_t fLatencyIndex; // -1 if invalid

  2214. 

  2215.     snd_seq_event_t fMidiEvents[kPluginMaxMidiEvents];

  2216. 

  2217.     // -------------------------------------------------------------------

  2218. 

  2219.     uint32_t getSafePortCount() const noexcept

  2220.     {

  2221.         if (fDescriptor->PortCount == 0)

  2222.             return 0;

  2223. 

  2224.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortDescriptors != nullptr, 0);

  2225.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortRangeHints != nullptr, 0);

  2226.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames != nullptr, 0);

  2227. 

  2228.         return static_cast<uint32_t>(fDescriptor->PortCount);

  2229.     }

  2230. 

  2231.     bool getSeparatedParameterNameOrUnit(const char* const paramName, char* const strBuf, const bool wantName) const noexcept

  2232.     {

  2233.         if (_getSeparatedParameterNameOrUnitImpl(paramName, strBuf, wantName, true))

  2234.             return true;

  2235.         if (_getSeparatedParameterNameOrUnitImpl(paramName, strBuf, wantName, false))

  2236.             return true;

  2237.         return false;

  2238.     }

  2239. 

  2240.     bool _getSeparatedParameterNameOrUnitImpl(const char* const paramName, char* const strBuf, const bool wantName, const bool useBracket) const noexcept

  2241.     {

  2242.         const char* const sepBracketStart(std::strstr(paramName, useBracket ? " [" : " ("));

  2243. 

  2244.         if (sepBracketStart == nullptr)

  2245.             return false;

  2246. 

  2247.         const char* const sepBracketEnd(std::strstr(sepBracketStart, useBracket ? "]" : ")"));

  2248. 

  2249.         if (sepBracketEnd == nullptr)

  2250.             return false;

  2251. 

  2252.         const size_t unitSize(static_cast<size_t>(sepBracketEnd-sepBracketStart-2));

  2253. 

  2254.         if (unitSize > 7) // very unlikely to have such big unit

  2255.             return false;

  2256. 

  2257.         const size_t sepIndex(std::strlen(paramName)-unitSize-3);

  2258. 

  2259.         // just in case

  2260.         if (sepIndex > STR_MAX)

  2261.             return false;

  2262. 

  2263.         if (wantName)

  2264.         {

  2265.             std::strncpy(strBuf, paramName, sepIndex);

  2266.             strBuf[sepIndex] = '\0';

  2267.         }

  2268.         else

  2269.         {

  2270.             std::strncpy(strBuf, paramName+(sepIndex+2), unitSize);

  2271.             strBuf[unitSize] = '\0';

  2272.         }

  2273. 

  2274.         return true;

  2275.     }

  2276. 

  2277.     // -------------------------------------------------------------------

  2278. 

  2279.     static LinkedList<const char*> sMultiSynthList;

  2280. 

  2281.     static bool addUniqueMultiSynth(const char* const label) noexcept

  2282.     {

  2283.         CARLA_SAFE_ASSERT_RETURN(label != nullptr && label[0] != '\0', false);

  2284. 

  2285.         const char* dlabel = nullptr;

  2286. 

  2287.         try {

  2288.             dlabel = carla_strdup(label);

  2289.         } catch(...) { return false; }

  2290. 

  2291.         for (LinkedList<const char*>::Itenerator it = sMultiSynthList.begin(); it.valid(); it.next())

  2292.         {

  2293.             const char* const itLabel(it.getValue());

  2294. 

  2295.             if (std::strcmp(dlabel, itLabel) == 0)

  2296.             {

  2297.                 delete[] dlabel;

  2298.                 return false;

  2299.             }

  2300.         }

  2301. 

  2302.         return sMultiSynthList.append(dlabel);

  2303.     }

  2304. 

  2305.     static void removeUniqueMultiSynth(const char* const label) noexcept

  2306.     {

  2307.         CARLA_SAFE_ASSERT_RETURN(label != nullptr && label[0] != '\0',);

  2308. 

  2309.         for (LinkedList<const char*>::Itenerator it = sMultiSynthList.begin(); it.valid(); it.next())

  2310.         {

  2311.             const char* const itLabel(it.getValue());

  2312. 

  2313.             if (std::strcmp(label, itLabel) == 0)

  2314.             {

  2315.                 sMultiSynthList.remove(it);

  2316.                 delete[] itLabel;

  2317.                 break;

  2318.             }

  2319.         }

  2320.     }

  2321. 

  2322.     // -------------------------------------------------------------------

  2323. 

  2324.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginDSSI)

  2325. };

  2326. 

  2327. LinkedList<const char*> CarlaPluginDSSI::sMultiSynthList;

  2328. 

  2329. // -------------------------------------------------------------------------------------------------------------------

  2330. 

  2331. CarlaPlugin* CarlaPlugin::newDSSI(const Initializer& init)

  2332. {

  2333.     carla_debug("CarlaPlugin::newDSSI({%p, \"%s\", \"%s\", \"%s\", " P_INT64 "})", init.engine, init.filename, init.name, init.label, init.uniqueId);

  2334. 

  2335.     CarlaPluginDSSI* const plugin(new CarlaPluginDSSI(init.engine, init.id));

  2336. 

  2337.     if (! plugin->init(init.filename, init.name, init.label))

  2338.     {

  2339.         delete plugin;

  2340.         return nullptr;

  2341.     }

  2342. 

  2343.     plugin->reload();

  2344. 

  2345.     bool canRun = true;

  2346. 

  2347.     if (init.engine->getProccessMode() == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  2348.     {

  2349.         if (! plugin->canRunInRack())

  2350.         {

  2351.             init.engine->setLastError("Carla's rack mode can only work with Mono or Stereo DSSI plugins, sorry!");

  2352.             canRun = false;

  2353.         }

  2354.         else if (plugin->getCVInCount() > 0 || plugin->getCVInCount() > 0)

  2355.         {

  2356.             init.engine->setLastError("Carla's rack mode cannot work with plugins that have CV ports, sorry!");

  2357.             canRun = false;

  2358.         }

  2359.     }

  2360.     else if (init.engine->getProccessMode() == ENGINE_PROCESS_MODE_PATCHBAY && (plugin->getCVInCount() > 0 || plugin->getCVInCount() > 0))

  2361.     {

  2362.         init.engine->setLastError("CV ports in patchbay mode is still TODO");

  2363.         canRun = false;

  2364.     }

  2365. 

  2366.     if (! canRun)

  2367.     {

  2368.         delete plugin;

  2369.         return nullptr;

  2370.     }

  2371. 

  2372.     return plugin;

  2373. }

  2374. 

  2375. // -------------------------------------------------------------------------------------------------------------------

  2376. 

  2377. CARLA_BACKEND_END_NAMESPACE