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

3145 lines
114KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin, LADSPA/DSSI implementation

  3.  * Copyright (C) 2011-2019 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. #include "CarlaPluginInternal.hpp"

  19. #include "CarlaEngineUtils.hpp"

  20. 

  21. #include "CarlaLadspaUtils.hpp"

  22. #include "CarlaDssiUtils.hpp"

  23. #include "CarlaMathUtils.hpp"

  24. 

  25. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  26. # include "CarlaOscUtils.hpp"

  27. # include "CarlaScopeUtils.hpp"

  28. # include "CarlaThread.hpp"

  29. # include "water/threads/ChildProcess.h"

  30. using water::ChildProcess;

  31. #endif

  32. 

  33. using water::String;

  34. using water::StringArray;

  35. 

  36. #define CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(/* argc, types, */ argcToCompare, typesToCompare) \

  37.     /* check argument count */                                                                  \

  38.     if (argc != argcToCompare)                                                                  \

  39.     {                                                                                           \

  40.         carla_stderr("CarlaPluginLADSPADSSI::%s() - argument count mismatch: %i != %i",         \

  41.                      __FUNCTION__, argc, argcToCompare);                                        \

  42.         return;                                                                                 \

  43.     }                                                                                           \

  44.     if (argc > 0)                                                                               \

  45.     {                                                                                           \

  46.         /* check for nullness */                                                                \

  47.         if (types == nullptr || typesToCompare == nullptr)                                      \

  48.         {                                                                                       \

  49.             carla_stderr("CarlaPluginLADSPADSSI::%s() - argument types are null",               \

  50.                          __FUNCTION__);                                                         \

  51.             return;                                                                             \

  52.         }                                                                                       \

  53.         /* check argument types */                                                              \

  54.         if (std::strcmp(types, typesToCompare) != 0)                                            \

  55.         {                                                                                       \

  56.             carla_stderr("CarlaPluginLADSPADSSI::%s() - argument types mismatch: '%s' != '%s'", \

  57.                          __FUNCTION__, types, typesToCompare);                                  \

  58.             return;                                                                             \

  59.         }                                                                                       \

  60.     }

  61. 

  62. CARLA_BACKEND_START_NAMESPACE

  63. 

  64. // -------------------------------------------------------------------

  65. // Fallback data

  66. 

  67. static const CustomData kCustomDataFallback = { nullptr, nullptr, nullptr };

  68. 

  69. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  70. // -------------------------------------------------------------------

  71. 

  72. class CarlaThreadDSSIUI : public CarlaThread

  73. {

  74. public:

  75.     CarlaThreadDSSIUI(CarlaEngine* const engine, CarlaPlugin* const plugin, const CarlaOscData& oscData) noexcept

  76.         : CarlaThread("CarlaThreadDSSIUI"),

  77.           kEngine(engine),

  78.           kPlugin(plugin),

  79.           fBinary(),

  80.           fLabel(),

  81.           fOscData(oscData),

  82.           fProcess() {}

  83. 

  84.     void setData(const char* const binary, const char* const label) noexcept

  85.     {

  86.         CARLA_SAFE_ASSERT_RETURN(binary != nullptr && binary[0] != '\0',);

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

  88.         CARLA_SAFE_ASSERT(! isThreadRunning());

  89. 

  90.         fBinary = binary;

  91.         fLabel  = label;

  92. 

  93.         if (fLabel.isEmpty())

  94.             fLabel = "\"\"";

  95.     }

  96. 

  97.     uintptr_t getProcessId() const noexcept

  98.     {

  99.         CARLA_SAFE_ASSERT_RETURN(fProcess != nullptr, 0);

  100. 

  101.         return (uintptr_t)fProcess->getPID();

  102.     }

  103. 

  104.     void run()

  105.     {

  106.         carla_stdout("LADSPA/DSSI UI thread started");

  107. 

  108.         if (fProcess == nullptr)

  109.         {

  110.             fProcess = new ChildProcess();

  111.         }

  112.         else if (fProcess->isRunning())

  113.         {

  114.             carla_stderr("CarlaThreadDSSI::run() - already running, giving up...");

  115. 

  116.             fProcess->kill();

  117.             fProcess = nullptr;

  118.             kEngine->callback(true, true,

  119.                               ENGINE_CALLBACK_UI_STATE_CHANGED,

  120.                               kPlugin->getId(),

  121.                               0,

  122.                               0, 0, 0.0f, nullptr);

  123.             return;

  124.         }

  125. 

  126.         String name(kPlugin->getName());

  127.         String filename(kPlugin->getFilename());

  128. 

  129.         if (name.isEmpty())

  130.             name = "(none)";

  131. 

  132.         if (filename.isEmpty())

  133.             filename = "\"\"";

  134. 

  135.         StringArray arguments;

  136. 

  137.         // binary

  138.         arguments.add(fBinary.buffer());

  139. 

  140.         // osc-url

  141.         arguments.add(String(kEngine->getOscServerPathUDP()) + String("/") + String(kPlugin->getId()));

  142. 

  143.         // filename

  144.         arguments.add(filename);

  145. 

  146.         // label

  147.         arguments.add(fLabel.buffer());

  148. 

  149.         // ui-title

  150.         arguments.add(name + String(" (GUI)"));

  151. 

  152.         bool started;

  153. 

  154.         {

  155. #ifdef CARLA_OS_LINUX

  156.             /*

  157.              * If the frontend uses winId parent, set LD_PRELOAD to auto-map the DSSI UI.

  158.              * If not, unset LD_PRELOAD.

  159.              */

  160.             const uintptr_t winId(kEngine->getOptions().frontendWinId);

  161. 

  162.             // for CARLA_ENGINE_OPTION_FRONTEND_WIN_ID

  163.             char winIdStr[STR_MAX+1];

  164.             winIdStr[STR_MAX] = '\0';

  165. 

  166.             // for LD_PRELOAD

  167.             CarlaString ldPreloadValue;

  168. 

  169.             if (winId != 0)

  170.             {

  171.                 std::snprintf(winIdStr, STR_MAX, P_UINTPTR, winId);

  172.                 ldPreloadValue = (CarlaString(kEngine->getOptions().binaryDir)

  173.                                + "/libcarla_interposer-x11.so");

  174.             }

  175.             else

  176.             {

  177.                 winIdStr[0] = '\0';

  178.             }

  179. 

  180.             const ScopedEngineEnvironmentLocker _seel(kEngine);

  181.             const CarlaScopedEnvVar _sev1("CARLA_ENGINE_OPTION_FRONTEND_WIN_ID", winIdStr[0] != '\0' ? winIdStr : nullptr);

  182.             const CarlaScopedEnvVar _sev2("LD_PRELOAD", ldPreloadValue.isNotEmpty() ? ldPreloadValue.buffer() : nullptr);

  183. #endif // CARLA_OS_LINUX

  184. 

  185.             // start the DSSI UI application

  186.             carla_stdout("starting DSSI UI...");

  187.             started = fProcess->start(arguments);

  188.         }

  189. 

  190.         if (! started)

  191.         {

  192.             carla_stdout("failed!");

  193.             fProcess = nullptr;

  194.             return;

  195.         }

  196. 

  197.         if (waitForOscGuiShow())

  198.         {

  199.             for (; fProcess->isRunning() && ! shouldThreadExit();)

  200.                 carla_sleep(1);

  201. 

  202.             // we only get here if UI was closed or thread asked to exit

  203.             if (fProcess->isRunning() && shouldThreadExit())

  204.             {

  205.                 fProcess->waitForProcessToFinish(static_cast<int>(kEngine->getOptions().uiBridgesTimeout));

  206. 

  207.                 if (fProcess->isRunning())

  208.                 {

  209.                     carla_stdout("CarlaThreadDSSIUI::run() - UI refused to close, force kill now");

  210.                     fProcess->kill();

  211.                 }

  212.                 else

  213.                 {

  214.                     carla_stdout("CarlaThreadDSSIUI::run() - UI auto-closed successfully");

  215.                 }

  216.             }

  217.             else if (fProcess->getExitCode() != 0 /*|| fProcess->exitStatus() == QProcess::CrashExit*/)

  218.                 carla_stderr("CarlaThreadDSSIUI::run() - UI crashed while running");

  219.             else

  220.                 carla_stdout("CarlaThreadDSSIUI::run() - UI closed cleanly");

  221.         }

  222.         else

  223.         {

  224.             fProcess->kill();

  225.             carla_stdout("CarlaThreadDSSIUI::run() - GUI timeout");

  226.         }

  227. 

  228.         fProcess = nullptr;

  229.         kEngine->callback(true, true,

  230.                           ENGINE_CALLBACK_UI_STATE_CHANGED,

  231.                           kPlugin->getId(),

  232.                           0,

  233.                           0, 0, 0.0f, nullptr);

  234. 

  235.         carla_stdout("LADSPA/DSSI UI thread finished");

  236.     }

  237. 

  238. private:

  239.     CarlaEngine* const kEngine;

  240.     CarlaPlugin* const kPlugin;

  241. 

  242.     CarlaString fBinary;

  243.     CarlaString fLabel;

  244. 

  245.     const CarlaOscData& fOscData;

  246.     CarlaScopedPointer<ChildProcess> fProcess;

  247. 

  248.     bool waitForOscGuiShow()

  249.     {

  250.         carla_stdout("CarlaThreadDSSIUI::waitForOscGuiShow()");

  251.         const uint uiBridgesTimeout = kEngine->getOptions().uiBridgesTimeout;

  252. 

  253.         // wait for UI 'update' call

  254.         for (uint i=0; i < uiBridgesTimeout/100; ++i)

  255.         {

  256.             if (fOscData.target != nullptr)

  257.             {

  258.                 carla_stdout("CarlaThreadDSSIUI::waitForOscGuiShow() - got response, asking UI to show itself now");

  259.                 osc_send_show(fOscData);

  260.                 return true;

  261.             }

  262. 

  263.             if (fProcess != nullptr && fProcess->isRunning() && ! shouldThreadExit())

  264.                 carla_msleep(100);

  265.             else

  266.                 return false;

  267.         }

  268. 

  269.         carla_stdout("CarlaThreadDSSIUI::waitForOscGuiShow() - Timeout while waiting for UI to respond"

  270.                      "(waited %u msecs)", uiBridgesTimeout);

  271.         return false;

  272.     }

  273. 

  274.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaThreadDSSIUI)

  275. };

  276. #endif

  277. 

  278. // -----------------------------------------------------

  279. 

  280. class CarlaPluginLADSPADSSI : public CarlaPlugin

  281. {

  282. public:

  283.     CarlaPluginLADSPADSSI(CarlaEngine* const engine, const uint id) noexcept

  284.         : CarlaPlugin(engine, id),

  285.           fHandles(),

  286.           fDescriptor(nullptr),

  287.           fDssiDescriptor(nullptr),

  288.           fRdfDescriptor(nullptr),

  289.           fAudioInBuffers(nullptr),

  290.           fAudioOutBuffers(nullptr),

  291.           fExtraStereoBuffer(),

  292.           fParamBuffers(nullptr),

  293.           fLatencyIndex(-1),

  294.           fForcedStereoIn(false),

  295.           fForcedStereoOut(false),

  296.           fNeedsFixedBuffers(false),

  297.           fUsesCustomData(false)

  298. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  299.         , fOscData(),

  300.           fThreadUI(engine, this, fOscData),

  301.           fUiFilename(nullptr)

  302. #endif

  303.     {

  304.         carla_debug("CarlaPluginLADSPADSSI::CarlaPluginLADSPADSSI(%p, %i)", engine, id);

  305. 

  306.         carla_zeroPointers(fExtraStereoBuffer, 2);

  307.     }

  308. 

  309.     ~CarlaPluginLADSPADSSI() noexcept override

  310.     {

  311.         carla_debug("CarlaPluginLADSPADSSI::~CarlaPluginLADSPADSSI()");

  312. 

  313. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  314.         // close UI

  315.         if (fUiFilename != nullptr)

  316.         {

  317.             showCustomUI(false);

  318. 

  319.             delete[] fUiFilename;

  320.             fUiFilename = nullptr;

  321.         }

  322. #endif

  323. 

  324.         pData->singleMutex.lock();

  325.         pData->masterMutex.lock();

  326. 

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

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

  329. 

  330.         if (pData->active)

  331.         {

  332.             deactivate();

  333.             pData->active = false;

  334.         }

  335. 

  336.         if (fDescriptor != nullptr)

  337.         {

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

  339.             {

  340.                 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  341.                 {

  342.                     LADSPA_Handle const handle(it.getValue(nullptr));

  343.                     CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  344. 

  345.                     try {

  346.                         fDescriptor->cleanup(handle);

  347.                     } CARLA_SAFE_EXCEPTION("LADSPA/DSSI cleanup");

  348.                 }

  349.             }

  350. 

  351.             fHandles.clear();

  352.             fDescriptor = nullptr;

  353.             fDssiDescriptor = nullptr;

  354.         }

  355. 

  356.         if (fRdfDescriptor != nullptr)

  357.         {

  358.             delete fRdfDescriptor;

  359.             fRdfDescriptor = nullptr;

  360.         }

  361. 

  362.         clearBuffers();

  363.     }

  364. 

  365.     // -------------------------------------------------------------------

  366.     // Information (base)

  367. 

  368.     PluginType getType() const noexcept override

  369.     {

  370.         return fDssiDescriptor != nullptr ? PLUGIN_DSSI : PLUGIN_LADSPA;

  371.     }

  372. 

  373.     PluginCategory getCategory() const noexcept override

  374.     {

  375.         if (fRdfDescriptor != nullptr)

  376.         {

  377.             const LADSPA_RDF_PluginType category = fRdfDescriptor->Type;

  378. 

  379.             // Specific Types

  380.             if (category & (LADSPA_RDF_PLUGIN_DELAY|LADSPA_RDF_PLUGIN_REVERB))

  381.                 return PLUGIN_CATEGORY_DELAY;

  382.             if (category & (LADSPA_RDF_PLUGIN_PHASER|LADSPA_RDF_PLUGIN_FLANGER|LADSPA_RDF_PLUGIN_CHORUS))

  383.                 return PLUGIN_CATEGORY_MODULATOR;

  384.             if (category & (LADSPA_RDF_PLUGIN_AMPLIFIER))

  385.                 return PLUGIN_CATEGORY_DYNAMICS;

  386.             if (category & (LADSPA_RDF_PLUGIN_UTILITY|LADSPA_RDF_PLUGIN_SPECTRAL|LADSPA_RDF_PLUGIN_FREQUENCY_METER))

  387.                 return PLUGIN_CATEGORY_UTILITY;

  388. 

  389.             // Pre-set LADSPA Types

  390.             if (LADSPA_RDF_IS_PLUGIN_DYNAMICS(category))

  391.                 return PLUGIN_CATEGORY_DYNAMICS;

  392.             if (LADSPA_RDF_IS_PLUGIN_AMPLITUDE(category))

  393.                 return PLUGIN_CATEGORY_MODULATOR;

  394.             if (LADSPA_RDF_IS_PLUGIN_EQ(category))

  395.                 return PLUGIN_CATEGORY_EQ;

  396.             if (LADSPA_RDF_IS_PLUGIN_FILTER(category))

  397.                 return PLUGIN_CATEGORY_FILTER;

  398.             if (LADSPA_RDF_IS_PLUGIN_FREQUENCY(category))

  399.                 return PLUGIN_CATEGORY_UTILITY;

  400.             if (LADSPA_RDF_IS_PLUGIN_SIMULATOR(category))

  401.                 return PLUGIN_CATEGORY_OTHER;

  402.             if (LADSPA_RDF_IS_PLUGIN_TIME(category))

  403.                 return PLUGIN_CATEGORY_DELAY;

  404.             if (LADSPA_RDF_IS_PLUGIN_GENERATOR(category))

  405.                 return PLUGIN_CATEGORY_SYNTH;

  406.         }

  407. 

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

  409.             if (pData->audioIn.count == 0 && pData->audioOut.count > 0)

  410.                 return PLUGIN_CATEGORY_SYNTH;

  411. 

  412.         return CarlaPlugin::getCategory();

  413.     }

  414. 

  415.     int64_t getUniqueId() const noexcept override

  416.     {

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

  418. 

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

  420.     }

  421. 

  422.     uint32_t getLatencyInFrames() const noexcept override

  423.     {

  424.         if (fLatencyIndex < 0 || fParamBuffers == nullptr)

  425.             return 0;

  426. 

  427.         const float latency(fParamBuffers[fLatencyIndex]);

  428.         CARLA_SAFE_ASSERT_RETURN(latency >= 0.0f, 0);

  429. 

  430.         return static_cast<uint32_t>(latency);

  431.     }

  432. 

  433.     // -------------------------------------------------------------------

  434.     // Information (count)

  435. 

  436.     uint32_t getParameterScalePointCount(const uint32_t parameterId) const noexcept override

  437.     {

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

  439. 

  440.         if (fRdfDescriptor == nullptr)

  441.             return 0;

  442. 

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

  444.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, 0);

  445. 

  446.         if (rindex >= static_cast<int32_t>(fRdfDescriptor->PortCount))

  447.             return 0;

  448. 

  449.         const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  450.         return static_cast<uint32_t>(port.ScalePointCount);

  451.     }

  452. 

  453.     // -------------------------------------------------------------------

  454.     // Information (current data)

  455. 

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

  457.     {

  458.         CARLA_SAFE_ASSERT_RETURN(fUsesCustomData, 0);

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

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

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

  462.         CARLA_SAFE_ASSERT_RETURN(fHandles.count() > 0, 0);

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

  464. 

  465.         *dataPtr = nullptr;

  466. 

  467.         int ret = 0;

  468.         ulong dataSize = 0;

  469. 

  470.         try {

  471.             ret = fDssiDescriptor->get_custom_data(fHandles.getFirst(nullptr), dataPtr, &dataSize);

  472.         } CARLA_SAFE_EXCEPTION_RETURN("CarlaPluginLADSPADSSI::getChunkData", 0);

  473. 

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

  475.     }

  476. 

  477.     // -------------------------------------------------------------------

  478.     // Information (per-plugin data)

  479. 

  480.     uint getOptionsAvailable() const noexcept override

  481.     {

  482.         uint options = 0x0;

  483. 

  484.         // can't disable fixed buffers if using latency

  485.         if (fLatencyIndex == -1 && ! fNeedsFixedBuffers)

  486.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  487. 

  488.         // can't disable forced stereo if enabled in the engine

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

  490.             pass();

  491.         // if inputs or outputs are just 1, then yes we can force stereo

  492.         else if (pData->audioIn.count == 1 || pData->audioOut.count == 1 || fForcedStereoIn || fForcedStereoOut)

  493.             options |= PLUGIN_OPTION_FORCE_STEREO;

  494. 

  495.         if (fDssiDescriptor != nullptr)

  496.         {

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

  498.                 options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  499. 

  500.             if (fUsesCustomData)

  501.                 options |= PLUGIN_OPTION_USE_CHUNKS;

  502. 

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

  504.             {

  505.                 options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  506.                 options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  507.                 options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  508.                 options |= PLUGIN_OPTION_SEND_PITCHBEND;

  509.                 options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  510.             }

  511.         }

  512. 

  513.         return options;

  514.     }

  515. 

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

  517.     {

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

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

  520. 

  521.         // bad plugins might have set output values out of bounds

  522.         if (pData->param.data[parameterId].type == PARAMETER_OUTPUT)

  523.             return pData->param.ranges[parameterId].getFixedValue(fParamBuffers[parameterId]);

  524. 

  525.         // not output, should be fine

  526.         return fParamBuffers[parameterId];

  527.     }

  528. 

  529.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept override

  530.     {

  531.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,        0.0f);

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

  533. 

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

  535.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0,                                              0.0f);

  536.         CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fRdfDescriptor->PortCount), 0.0f);

  537. 

  538.         const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  539.         CARLA_SAFE_ASSERT_RETURN(scalePointId < port.ScalePointCount, 0.0f);

  540. 

  541.         const LADSPA_RDF_ScalePoint& scalePoint(port.ScalePoints[scalePointId]);

  542.         return pData->param.ranges[parameterId].getFixedValue(scalePoint.Value);

  543.     }

  544. 

  545.     bool getLabel(char* const strBuf) const noexcept override

  546.     {

  547.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);

  548.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Label != nullptr, false);

  549. 

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

  551.         return true;

  552.     }

  553. 

  554.     bool getMaker(char* const strBuf) const noexcept override

  555.     {

  556.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);

  557.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Maker != nullptr, false);

  558. 

  559.         if (fRdfDescriptor != nullptr && fRdfDescriptor->Creator != nullptr)

  560.             std::strncpy(strBuf, fRdfDescriptor->Creator, STR_MAX);

  561.         else

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

  563. 

  564.         return true;

  565.     }

  566. 

  567.     bool getCopyright(char* const strBuf) const noexcept override

  568.     {

  569.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);

  570.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Copyright != nullptr, false);

  571. 

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

  573.         return true;

  574.     }

  575. 

  576.     bool getRealName(char* const strBuf) const noexcept override

  577.     {

  578.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);

  579.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Name != nullptr, false);

  580. 

  581.         if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr)

  582.             std::strncpy(strBuf, fRdfDescriptor->Title, STR_MAX);

  583.         else

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

  585. 

  586.         return true;

  587.     }

  588. 

  589.     bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override

  590.     {

  591.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);

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

  593. 

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

  595.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  596.         CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fDescriptor->PortCount), false);

  597.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames[rindex] != nullptr, false);

  598. 

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

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

  601. 

  602.         return true;

  603.     }

  604. 

  605.     bool getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override

  606.     {

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

  608. 

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

  610.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  611. 

  612.         if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  613.         {

  614.             const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  615. 

  616.             if (LADSPA_RDF_PORT_HAS_UNIT(port.Hints))

  617.             {

  618.                 switch (port.Unit)

  619.                 {

  620.                 case LADSPA_RDF_UNIT_DB:

  621.                     std::strncpy(strBuf, "dB", STR_MAX);

  622.                     return true;

  623.                 case LADSPA_RDF_UNIT_COEF:

  624.                     std::strncpy(strBuf, "(coef)", STR_MAX);

  625.                     return true;

  626.                 case LADSPA_RDF_UNIT_HZ:

  627.                     std::strncpy(strBuf, "Hz", STR_MAX);

  628.                     return true;

  629.                 case LADSPA_RDF_UNIT_S:

  630.                     std::strncpy(strBuf, "s", STR_MAX);

  631.                     return true;

  632.                 case LADSPA_RDF_UNIT_MS:

  633.                     std::strncpy(strBuf, "ms", STR_MAX);

  634.                     return true;

  635.                 case LADSPA_RDF_UNIT_MIN:

  636.                     std::strncpy(strBuf, "min", STR_MAX);

  637.                     return true;

  638.                 }

  639.             }

  640.         }

  641. 

  642.         CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fDescriptor->PortCount), false);

  643.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames[rindex] != nullptr, false);

  644. 

  645.         return getSeparatedParameterNameOrUnit(fDescriptor->PortNames[rindex], strBuf, false);

  646.     }

  647. 

  648.     bool getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept override

  649.     {

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

  651. 

  652.         if (fRdfDescriptor == nullptr)

  653.             return false;

  654. 

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

  656.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  657. 

  658.         if (rindex >= static_cast<int32_t>(fRdfDescriptor->PortCount))

  659.             return false;

  660. 

  661.         const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  662. 

  663.         if (! LADSPA_RDF_PORT_HAS_LABEL(port.Hints))

  664.             return false;

  665. 

  666.         CARLA_SAFE_ASSERT_RETURN(port.Label != nullptr, false);

  667. 

  668.         std::strncpy(strBuf, port.Label, STR_MAX);

  669.         return true;

  670.     }

  671. 

  672.     bool getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept override

  673.     {

  674.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

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

  676. 

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

  678.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  679.         CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fRdfDescriptor->PortCount), false);

  680. 

  681.         const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  682.         CARLA_SAFE_ASSERT_RETURN(scalePointId < port.ScalePointCount, false);

  683. 

  684.         const LADSPA_RDF_ScalePoint& scalePoint(port.ScalePoints[scalePointId]);

  685.         CARLA_SAFE_ASSERT_RETURN(scalePoint.Label != nullptr, false);

  686. 

  687.         std::strncpy(strBuf, scalePoint.Label, STR_MAX);

  688.         return true;

  689.     }

  690. 

  691.     // -------------------------------------------------------------------

  692.     // Set data (state)

  693. 

  694.     // nothing

  695. 

  696.     // -------------------------------------------------------------------

  697.     // Set data (internal stuff)

  698. 

  699.     void setId(const uint newId) noexcept override

  700.     {

  701.         CarlaPlugin::setId(newId);

  702. 

  703.         // UI osc-url uses Id, so we need to close it when it changes

  704.         // FIXME - must be RT safe

  705.         showCustomUI(false);

  706.     }

  707. 

  708.     // -------------------------------------------------------------------

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

  710. 

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

  712.     {

  713.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  715. 

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

  717.         fParamBuffers[parameterId] = fixedValue;

  718. 

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

  720.     }

  721. 

  722.     void setParameterValueRT(const uint32_t parameterId, const float value, const bool sendCallbackLater) noexcept override

  723.     {

  724.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  726. 

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

  728.         fParamBuffers[parameterId] = fixedValue;

  729. 

  730.         CarlaPlugin::setParameterValueRT(parameterId, fixedValue, sendCallbackLater);

  731.     }

  732. 

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

  734.     {

  735.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);

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

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

  738.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  740. 

  741.         if (std::strcmp(type, CUSTOM_DATA_TYPE_PROPERTY) == 0)

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

  743. 

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

  745.             return carla_stderr2("CarlaPluginLADSPADSSI::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is not string",

  746.                                  type, key, value, bool2str(sendGui));

  747. 

  748.         if (fDssiDescriptor->configure != nullptr && fHandles.count() > 0)

  749.         {

  750.             for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  751.             {

  752.                 LADSPA_Handle const handle(it.getValue(nullptr));

  753.                 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  754. 

  755.                 try {

  756.                     fDssiDescriptor->configure(handle, key, value);

  757.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI setCustomData");

  758.             }

  759.         }

  760. 

  761. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  762.         if (sendGui && fOscData.target != nullptr)

  763.             osc_send_configure(fOscData, key, value);

  764. #endif

  765. 

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

  767.         {

  768.             const ScopedSingleProcessLocker spl(this, true);

  769.             reloadPrograms(false);

  770.         }

  771. 

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

  773.     }

  774. 

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

  776.     {

  777.         CARLA_SAFE_ASSERT_RETURN(fUsesCustomData,);

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

  779.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);

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

  781.         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  782.         CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

  783. 

  784.         if (fHandles.count() > 0)

  785.         {

  786.             const ScopedSingleProcessLocker spl(this, true);

  787. 

  788.             for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  789.             {

  790.                 LADSPA_Handle const handle(it.getValue(nullptr));

  791.                 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  792. 

  793.                 try {

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

  795.                 } CARLA_SAFE_EXCEPTION("CarlaPluginLADSPADSSI::setChunkData");

  796.             }

  797.         }

  798. 

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

  800.     }

  801. 

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

  803.     {

  804.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);

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

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

  807.         CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback || doingInit,);

  808. 

  809.         if (index >= 0 && fHandles.count() > 0)

  810.         {

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

  812. 

  813.             setMidiProgramInDSSI(static_cast<uint32_t>(index));

  814.         }

  815. 

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

  817.     }

  818. 

  819.     void setMidiProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept override

  820.     {

  821.         CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);

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

  823.         CARLA_SAFE_ASSERT_RETURN(uindex < pData->midiprog.count,);

  824. 

  825.         setMidiProgramInDSSI(uindex);

  826. 

  827.         CarlaPlugin::setMidiProgramRT(uindex, sendCallbackLater);

  828.     }

  829. 

  830.     void setMidiProgramInDSSI(const uint32_t uindex) noexcept

  831.     {

  832.         const uint32_t bank(pData->midiprog.data[uindex].bank);

  833.         const uint32_t program(pData->midiprog.data[uindex].program);

  834. 

  835.         for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  836.         {

  837.             LADSPA_Handle const handle(it.getValue(nullptr));

  838.             CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  839. 

  840.             try {

  841.                 fDssiDescriptor->select_program(handle, bank, program);

  842.             } CARLA_SAFE_EXCEPTION("LADSPA/DSSI setMidiProgram")

  843.         }

  844.     }

  845. 

  846. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  847.     // -------------------------------------------------------------------

  848.     // Set ui stuff

  849. 

  850.     void showCustomUI(const bool yesNo) override

  851.     {

  852.         if (yesNo)

  853.         {

  854.             fOscData.clear();

  855.             fThreadUI.startThread();

  856.         }

  857.         else

  858.         {

  859. #ifndef BUILD_BRIDGE

  860.             pData->transientTryCounter = 0;

  861. #endif

  862. 

  863.             if (fOscData.target != nullptr)

  864.             {

  865.                 osc_send_hide(fOscData);

  866.                 osc_send_quit(fOscData);

  867.                 fOscData.clear();

  868.             }

  869. 

  870.             fThreadUI.stopThread(static_cast<int>(pData->engine->getOptions().uiBridgesTimeout * 2));

  871.         }

  872.     }

  873. #endif

  874. 

  875.     // -------------------------------------------------------------------

  876.     // Plugin state

  877. 

  878.     void reload() override

  879.     {

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

  881.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  882.         CARLA_SAFE_ASSERT_RETURN(fHandles.count() > 0,);

  883.         carla_debug("CarlaPluginLADSPADSSI::reload() - start");

  884. 

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

  886. 

  887.         // Safely disable plugin for reload

  888.         const ScopedDisabler sd(this);

  889. 

  890.         if (pData->active)

  891.             deactivate();

  892. 

  893.         clearBuffers();

  894. 

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

  896.         const uint32_t portCount(getSafePortCount());

  897. 

  898.         uint32_t aIns, aOuts, mIns, params;

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

  900. 

  901.         bool forcedStereoIn, forcedStereoOut;

  902.         forcedStereoIn = forcedStereoOut = false;

  903. 

  904.         bool needsCtrlIn, needsCtrlOut;

  905.         needsCtrlIn = needsCtrlOut = false;

  906. 

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

  908.         {

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

  910. 

  911.             if (LADSPA_IS_PORT_AUDIO(portType))

  912.             {

  913.                 if (LADSPA_IS_PORT_INPUT(portType))

  914.                     aIns += 1;

  915.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  916.                     aOuts += 1;

  917.             }

  918.             else if (LADSPA_IS_PORT_CONTROL(portType))

  919.                 params += 1;

  920.         }

  921. 

  922.         if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  923.         {

  924.             if ((aIns == 1 || aOuts == 1) && fHandles.count() == 1 && addInstance())

  925.             {

  926.                 if (aIns == 1)

  927.                 {

  928.                     aIns = 2;

  929.                     forcedStereoIn = true;

  930.                 }

  931.                 if (aOuts == 1)

  932.                 {

  933.                     aOuts = 2;

  934.                     forcedStereoOut = true;

  935.                 }

  936.             }

  937.         }

  938. 

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

  940.         {

  941.             mIns = 1;

  942.             needsCtrlIn = true;

  943.         }

  944. 

  945.         if (aIns > 0)

  946.         {

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

  948.             fAudioInBuffers = new float*[aIns];

  949. 

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

  951.                 fAudioInBuffers[i] = nullptr;

  952.         }

  953. 

  954.         if (aOuts > 0)

  955.         {

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

  957.             fAudioOutBuffers = new float*[aOuts];

  958.             needsCtrlIn = true;

  959. 

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

  961.                 fAudioOutBuffers[i] = nullptr;

  962.         }

  963. 

  964.         if (params > 0)

  965.         {

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

  967. 

  968.             fParamBuffers = new float[params];

  969.             carla_zeroFloats(fParamBuffers, params);

  970.         }

  971. 

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

  973.         CarlaString portName;

  974. 

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

  976.         {

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

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

  979.             const bool hasPortRDF = (fRdfDescriptor != nullptr && i < fRdfDescriptor->PortCount);

  980. 

  981.             if (LADSPA_IS_PORT_AUDIO(portType))

  982.             {

  983.                 portName.clear();

  984. 

  985.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  986.                 {

  987.                     portName  = pData->name;

  988.                     portName += ":";

  989.                 }

  990. 

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

  992.                 {

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

  994.                 }

  995.                 else

  996.                 {

  997.                     if (LADSPA_IS_PORT_INPUT(portType))

  998.                     {

  999.                         if (aIns > 1)

  1000.                         {

  1001.                             portName += "audio-in_";

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

  1003.                         }

  1004.                         else

  1005.                             portName += "audio-in";

  1006.                     }

  1007.                     else

  1008.                     {

  1009.                         if (aOuts > 1)

  1010.                         {

  1011.                             portName += "audio-out_";

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

  1013.                         }

  1014.                         else

  1015.                             portName += "audio-out";

  1016.                     }

  1017.                 }

  1018. 

  1019.                 portName.truncate(portNameSize);

  1020. 

  1021.                 if (LADSPA_IS_PORT_INPUT(portType))

  1022.                 {

  1023.                     const uint32_t j = iAudioIn++;

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

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

  1026. 

  1027.                     if (forcedStereoIn)

  1028.                     {

  1029.                         portName += "_2";

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

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

  1032.                     }

  1033.                 }

  1034.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  1035.                 {

  1036.                     const uint32_t j = iAudioOut++;

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

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

  1039. 

  1040.                     if (forcedStereoOut)

  1041.                     {

  1042.                         portName += "_2";

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

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

  1045.                     }

  1046.                 }

  1047.                 else

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

  1049.             }

  1050.             else if (LADSPA_IS_PORT_CONTROL(portType))

  1051.             {

  1052.                 const uint32_t j = iCtrl++;

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

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

  1055. 

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

  1057. 

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

  1059. 

  1060.                 // min value

  1061.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  1062.                     min = portRangeHints.LowerBound;

  1063.                 else

  1064.                     min = 0.0f;

  1065. 

  1066.                 // max value

  1067.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  1068.                     max = portRangeHints.UpperBound;

  1069.                 else

  1070.                     max = 1.0f;

  1071. 

  1072.                 if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  1073.                 {

  1074.                     min *= sampleRate;

  1075.                     max *= sampleRate;

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

  1077.                 }

  1078. 

  1079.                 if (min >= max)

  1080.                 {

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

  1082.                     max = min + 0.1f;

  1083.                 }

  1084. 

  1085.                 // default value

  1086.                 if (hasPortRDF && LADSPA_RDF_PORT_HAS_DEFAULT(fRdfDescriptor->Ports[i].Hints))

  1087.                     def = fRdfDescriptor->Ports[i].Default;

  1088.                 else

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

  1090. 

  1091.                 if (def < min)

  1092.                     def = min;

  1093.                 else if (def > max)

  1094.                     def = max;

  1095. 

  1096.                 if (LADSPA_IS_HINT_TOGGLED(portRangeHints.HintDescriptor))

  1097.                 {

  1098.                     step = max - min;

  1099.                     stepSmall = step;

  1100.                     stepLarge = step;

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

  1102.                 }

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

  1104.                 {

  1105.                     step = 1.0f;

  1106.                     stepSmall = 1.0f;

  1107.                     stepLarge = 10.0f;

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

  1109.                 }

  1110.                 else

  1111.                 {

  1112.                     const float range = max - min;

  1113.                     step = range/100.0f;

  1114.                     stepSmall = range/1000.0f;

  1115.                     stepLarge = range/10.0f;

  1116.                 }

  1117. 

  1118.                 if (LADSPA_IS_PORT_INPUT(portType))

  1119.                 {

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

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

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

  1123.                     needsCtrlIn = true;

  1124. 

  1125.                     // MIDI CC value

  1126.                     if (fDssiDescriptor != nullptr && fDssiDescriptor->get_midi_controller_for_port != nullptr)

  1127.                     {

  1128.                         const int ctrl = fDssiDescriptor->get_midi_controller_for_port(fHandles.getFirst(nullptr), i);

  1129.                         if (DSSI_CONTROLLER_IS_SET(ctrl) && DSSI_IS_CC(ctrl))

  1130.                         {

  1131.                             const int16_t cc = DSSI_CC_NUMBER(ctrl);

  1132.                             if (! MIDI_IS_CONTROL_BANK_SELECT(cc))

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

  1134.                         }

  1135.                     }

  1136.                 }

  1137.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  1138.                 {

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

  1140. 

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

  1142.                     {

  1143.                         min = 0.0f;

  1144.                         max = sampleRate;

  1145.                         def = 0.0f;

  1146.                         step = 1.0f;

  1147.                         stepSmall = 1.0f;

  1148.                         stepLarge = 1.0f;

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

  1150.                         CARLA_SAFE_ASSERT_INT2(fLatencyIndex == static_cast<int32_t>(j), fLatencyIndex, j);

  1151.                     }

  1152.                     else

  1153.                     {

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

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

  1156.                         needsCtrlOut = true;

  1157.                     }

  1158.                 }

  1159.                 else

  1160.                 {

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

  1162.                 }

  1163. 

  1164.                 // extra parameter hints

  1165.                 if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor))

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

  1167. 

  1168.                 // check for scalepoints, require at least 2 to make it useful

  1169.                 if (hasPortRDF && fRdfDescriptor->Ports[i].ScalePointCount >= 2)

  1170.                     pData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;

  1171. 

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

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

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

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

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

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

  1178. 

  1179.                 // Start parameters in their default values

  1180.                 fParamBuffers[j] = def;

  1181. 

  1182.                 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  1183.                 {

  1184.                     LADSPA_Handle const handle(it.getValue(nullptr));

  1185.                     CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  1186. 

  1187.                     try {

  1188.                         fDescriptor->connect_port(handle, i, &fParamBuffers[j]);

  1189.                     } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (parameter)");

  1190.                 }

  1191.             }

  1192.             else

  1193.             {

  1194.                 // Not Audio or Control

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

  1196. 

  1197.                 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  1198.                 {

  1199.                     LADSPA_Handle const handle(it.getValue(nullptr));

  1200.                     CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  1201. 

  1202.                     try {

  1203.                         fDescriptor->connect_port(handle, i, nullptr);

  1204.                     } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (null)");

  1205.                 }

  1206.             }

  1207.         }

  1208. 

  1209.         if (needsCtrlIn)

  1210.         {

  1211.             portName.clear();

  1212. 

  1213.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1214.             {

  1215.                 portName  = pData->name;

  1216.                 portName += ":";

  1217.             }

  1218. 

  1219.             portName += "events-in";

  1220.             portName.truncate(portNameSize);

  1221. 

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

  1223.         }

  1224. 

  1225.         if (needsCtrlOut)

  1226.         {

  1227.             portName.clear();

  1228. 

  1229.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1230.             {

  1231.                 portName  = pData->name;

  1232.                 portName += ":";

  1233.             }

  1234. 

  1235.             portName += "events-out";

  1236.             portName.truncate(portNameSize);

  1237. 

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

  1239.         }

  1240. 

  1241.         if (forcedStereoIn || forcedStereoOut)

  1242.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1243.         else

  1244.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  1245. 

  1246.         // plugin hints

  1247.         pData->hints = 0x0;

  1248. 

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

  1250.             pData->hints |= PLUGIN_IS_RTSAFE;

  1251. 

  1252. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  1253.         if (fUiFilename != nullptr)

  1254.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  1255. #endif

  1256. 

  1257. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1259.             pData->hints |= PLUGIN_CAN_DRYWET;

  1260. 

  1261.         if (aOuts > 0)

  1262.             pData->hints |= PLUGIN_CAN_VOLUME;

  1263. 

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

  1265.             pData->hints |= PLUGIN_CAN_BALANCE;

  1266. #endif

  1267. 

  1268.         // extra plugin hints

  1269.         pData->extraHints = 0x0;

  1270. 

  1271.         if (mIns > 0)

  1272.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  1273. 

  1274.         // check initial latency

  1275.         findInitialLatencyValue(aIns, aOuts);

  1276. 

  1277.         fForcedStereoIn  = forcedStereoIn;

  1278.         fForcedStereoOut = forcedStereoOut;

  1279. 

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

  1281.         reloadPrograms(true);

  1282. 

  1283.         if (pData->active)

  1284.             activate();

  1285. 

  1286.         carla_debug("CarlaPluginLADSPADSSI::reload() - end");

  1287.     }

  1288. 

  1289.     void findInitialLatencyValue(const uint32_t aIns, const uint32_t aOuts) const

  1290.     {

  1291.         if (fLatencyIndex < 0 || fHandles.count() == 0)

  1292.             return;

  1293. 

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

  1295.         const LADSPA_Handle handle(fHandles.getFirst(nullptr));

  1296.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  1297. 

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

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

  1300. 

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

  1302.         {

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

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

  1305. 

  1306.             try {

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

  1308.             } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (latency input)");

  1309.         }

  1310. 

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

  1312.         {

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

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

  1315. 

  1316.             try {

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

  1318.             } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (latency output)");

  1319.         }

  1320. 

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

  1322.         {

  1323.             try {

  1324.                 fDescriptor->activate(handle);

  1325.             } CARLA_SAFE_EXCEPTION("LADSPA/DSSI latency activate");

  1326.         }

  1327. 

  1328.         try {

  1329.             fDescriptor->run(handle, 2);

  1330.         } CARLA_SAFE_EXCEPTION("LADSPA/DSSI latency run");

  1331. 

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

  1333.         {

  1334.             try {

  1335.                 fDescriptor->deactivate(handle);

  1336.             } CARLA_SAFE_EXCEPTION("LADSPA/DSSI latency deactivate");

  1337.         }

  1338. 

  1339.         // done, let's get the value

  1340.         if (const uint32_t latency = getLatencyInFrames())

  1341.         {

  1342.             pData->client->setLatency(latency);

  1343. #ifndef BUILD_BRIDGE

  1344.             pData->latency.recreateBuffers(std::max(aIns, aOuts), latency);

  1345. #endif

  1346.         }

  1347.     }

  1348. 

  1349.     void reloadPrograms(const bool doInit) override

  1350.     {

  1351.         carla_debug("CarlaPluginLADSPADSSI::reloadPrograms(%s)", bool2str(doInit));

  1352. 

  1353.         const LADSPA_Handle handle(fHandles.getFirst(nullptr));

  1354.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  1355. 

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

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

  1358. 

  1359.         // Delete old programs

  1360.         pData->midiprog.clear();

  1361. 

  1362.         // nothing to do for simple LADSPA plugins (do we want to bother with lrdf presets?)

  1363.         if (fDssiDescriptor == nullptr)

  1364.             return;

  1365. 

  1366.         // Query new programs

  1367.         uint32_t newCount = 0;

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

  1369.         {

  1370.             for (; fDssiDescriptor->get_program(handle, newCount) != nullptr;)

  1371.                 ++newCount;

  1372.         }

  1373. 

  1374.         if (newCount > 0)

  1375.         {

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

  1377. 

  1378.             // Update data

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

  1380.             {

  1381.                 const DSSI_Program_Descriptor* const pdesc(fDssiDescriptor->get_program(handle, i));

  1382.                 CARLA_SAFE_ASSERT_CONTINUE(pdesc != nullptr);

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

  1384. 

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

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

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

  1388.             }

  1389.         }

  1390. 

  1391.         if (doInit)

  1392.         {

  1393.             if (newCount > 0)

  1394.                 setMidiProgram(0, false, false, false, true);

  1395.         }

  1396.         else

  1397.         {

  1398.             // Check if current program is invalid

  1399.             bool programChanged = false;

  1400. 

  1401.             if (newCount == oldCount+1)

  1402.             {

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

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

  1405.                 programChanged = true;

  1406.             }

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

  1408.             {

  1409.                 // programs exist now, but not before

  1410.                 pData->midiprog.current = 0;

  1411.                 programChanged = true;

  1412.             }

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

  1414.             {

  1415.                 // programs existed before, but not anymore

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

  1417.                 programChanged = true;

  1418.             }

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

  1420.             {

  1421.                 // current midi program > count

  1422.                 pData->midiprog.current = 0;

  1423.                 programChanged = true;

  1424.             }

  1425.             else

  1426.             {

  1427.                 // no change

  1428.                 pData->midiprog.current = current;

  1429.             }

  1430. 

  1431.             if (programChanged)

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

  1433. 

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

  1435.         }

  1436.     }

  1437. 

  1438.     // -------------------------------------------------------------------

  1439.     // Plugin processing

  1440. 

  1441.     void activate() noexcept override

  1442.     {

  1443.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1444. 

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

  1446.         {

  1447.             for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  1448.             {

  1449.                 LADSPA_Handle const handle(it.getValue(nullptr));

  1450.                 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  1451. 

  1452.                 try {

  1453.                     fDescriptor->activate(handle);

  1454.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI activate");

  1455.             }

  1456.         }

  1457.     }

  1458. 

  1459.     void deactivate() noexcept override

  1460.     {

  1461.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1462. 

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

  1464.         {

  1465.             for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  1466.             {

  1467.                 LADSPA_Handle const handle(it.getValue(nullptr));

  1468.                 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  1469. 

  1470.                 try {

  1471.                     fDescriptor->deactivate(handle);

  1472.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI deactivate");

  1473.             }

  1474.         }

  1475.     }

  1476. 

  1477.     void process(const float** const audioIn, float** const audioOut, const float** const, float** const, const uint32_t frames) override

  1478.     {

  1479.         // --------------------------------------------------------------------------------------------------------

  1480.         // Check if active

  1481. 

  1482.         if (! pData->active)

  1483.         {

  1484.             // disable any output sound

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

  1486.                 carla_zeroFloats(audioOut[i], frames);

  1487.             return;

  1488.         }

  1489. 

  1490.         ulong midiEventCount = 0;

  1491.         carla_zeroStructs(fMidiEvents, kPluginMaxMidiEvents);

  1492. 

  1493.         // --------------------------------------------------------------------------------------------------------

  1494.         // Check if needs reset

  1495. 

  1496.         if (pData->needsReset)

  1497.         {

  1498.             if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1499.             {

  1500.                 midiEventCount = MAX_MIDI_CHANNELS*2;

  1501. 

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

  1503.                 {

  1504.                     fMidiEvents[i].type = SND_SEQ_EVENT_CONTROLLER;

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

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

  1507. 

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

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

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

  1511.                 }

  1512.             }

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

  1514.             {

  1515.                 midiEventCount = MAX_MIDI_NOTE;

  1516. 

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

  1518.                 {

  1519.                     fMidiEvents[i].type = SND_SEQ_EVENT_NOTEOFF;

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

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

  1522.                 }

  1523.             }

  1524. 

  1525.             pData->needsReset = false;

  1526.         }

  1527. 

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

  1529.         // Event Input and Processing

  1530. 

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

  1532.         {

  1533.             // ----------------------------------------------------------------------------------------------------

  1534.             // MIDI Input (External)

  1535. 

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

  1537.             {

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

  1539. 

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

  1541.                 {

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

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

  1544. 

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

  1546. 

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

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

  1549.                     seqEvent.data.note.note     = note.note;

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

  1551.                 }

  1552. 

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

  1554. 

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

  1556. 

  1557.             // ----------------------------------------------------------------------------------------------------

  1558.             // Event Input (System)

  1559. 

  1560. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1561.             bool allNotesOffSent = false;

  1562. #endif

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

  1564. 

  1565.             uint32_t startTime  = 0;

  1566.             uint32_t timeOffset = 0;

  1567.             uint32_t nextBankId;

  1568. 

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

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

  1571.             else

  1572.                 nextBankId = 0;

  1573. 

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

  1575.             {

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

  1577. 

  1578.                 uint32_t eventTime = event.time;

  1579.                 CARLA_SAFE_ASSERT_UINT2_CONTINUE(eventTime < frames, eventTime, frames);

  1580. 

  1581.                 if (eventTime < timeOffset)

  1582.                 {

  1583.                     carla_stderr2("Timing error, eventTime:%u < timeOffset:%u for '%s'",

  1584.                                   eventTime, timeOffset, pData->name);

  1585.                     eventTime = timeOffset;

  1586.                 }

  1587. 

  1588.                 if (isSampleAccurate && eventTime > timeOffset)

  1589.                 {

  1590.                     if (processSingle(audioIn, audioOut, eventTime - timeOffset, timeOffset, midiEventCount))

  1591.                     {

  1592.                         startTime  = 0;

  1593.                         timeOffset = eventTime;

  1594.                         midiEventCount = 0;

  1595. 

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

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

  1598.                         else

  1599.                             nextBankId = 0;

  1600.                     }

  1601.                     else

  1602.                         startTime += timeOffset;

  1603.                 }

  1604. 

  1605.                 switch (event.type)

  1606.                 {

  1607.                 case kEngineEventTypeNull:

  1608.                     break;

  1609. 

  1610.                 case kEngineEventTypeControl: {

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

  1612. 

  1613.                     switch (ctrlEvent.type)

  1614.                     {

  1615.                     case kEngineControlEventTypeNull:

  1616.                         break;

  1617. 

  1618.                     case kEngineControlEventTypeParameter: {

  1619. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1620.                         // Control backend stuff

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

  1622.                         {

  1623.                             float value;

  1624. 

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

  1626.                             {

  1627.                                 value = ctrlEvent.value;

  1628.                                 setDryWetRT(value, true);

  1629.                             }

  1630. 

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

  1632.                             {

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

  1634.                                 setVolumeRT(value, true);

  1635.                             }

  1636. 

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

  1638.                             {

  1639.                                 float left, right;

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

  1641. 

  1642.                                 if (value < 0.0f)

  1643.                                 {

  1644.                                     left  = -1.0f;

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

  1646.                                 }

  1647.                                 else if (value > 0.0f)

  1648.                                 {

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

  1650.                                     right = 1.0f;

  1651.                                 }

  1652.                                 else

  1653.                                 {

  1654.                                     left  = -1.0f;

  1655.                                     right = 1.0f;

  1656.                                 }

  1657. 

  1658.                                 setBalanceLeftRT(left, true);

  1659.                                 setBalanceRightRT(right, true);

  1660.                             }

  1661.                         }

  1662. #endif

  1663.                         // Control plugin parameters

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

  1665.                         {

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

  1667.                                 continue;

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

  1669.                                 continue;

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

  1671.                                 continue;

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

  1673.                                 continue;

  1674. 

  1675.                             float value;

  1676. 

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

  1678.                             {

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

  1680.                             }

  1681.                             else

  1682.                             {

  1683.                                 if (pData->param.data[k].hints & PARAMETER_IS_LOGARITHMIC)

  1684.                                     value = pData->param.ranges[k].getUnnormalizedLogValue(ctrlEvent.value);

  1685.                                 else

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

  1687. 

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

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

  1690.                             }

  1691. 

  1692.                             setParameterValueRT(k, value, true);

  1693.                         }

  1694. 

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

  1696.                         {

  1697.                             if (midiEventCount >= kPluginMaxMidiEvents)

  1698.                                 continue;

  1699. 

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

  1701. 

  1702.                             seqEvent.time.tick = isSampleAccurate ? startTime : eventTime;

  1703. 

  1704.                             seqEvent.type = SND_SEQ_EVENT_CONTROLLER;

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

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

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

  1708.                         }

  1709. 

  1710.                         break;

  1711.                     } // case kEngineControlEventTypeParameter

  1712. 

  1713.                     case kEngineControlEventTypeMidiBank:

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

  1715.                             nextBankId = ctrlEvent.param;

  1716.                         break;

  1717. 

  1718.                     case kEngineControlEventTypeMidiProgram:

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

  1720.                         {

  1721.                             const uint32_t nextProgramId = ctrlEvent.param;

  1722. 

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

  1724.                             {

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

  1726.                                 {

  1727.                                     setMidiProgramRT(k, true);

  1728.                                     break;

  1729.                                 }

  1730.                             }

  1731.                         }

  1732.                         break;

  1733. 

  1734.                     case kEngineControlEventTypeAllSoundOff:

  1735.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1736.                         {

  1737.                             if (midiEventCount >= kPluginMaxMidiEvents)

  1738.                                 continue;

  1739. 

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

  1741. 

  1742.                             seqEvent.time.tick = isSampleAccurate ? startTime : eventTime;

  1743. 

  1744.                             seqEvent.type = SND_SEQ_EVENT_CONTROLLER;

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

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

  1747.                         }

  1748.                         break;

  1749. 

  1750.                     case kEngineControlEventTypeAllNotesOff:

  1751.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1752.                         {

  1753. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1755.                             {

  1756.                                 allNotesOffSent = true;

  1757.                                 postponeRtAllNotesOff();

  1758.                             }

  1759. #endif

  1760. 

  1761.                             if (midiEventCount >= kPluginMaxMidiEvents)

  1762.                                 continue;

  1763. 

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

  1765. 

  1766.                             seqEvent.time.tick = isSampleAccurate ? startTime : eventTime;

  1767. 

  1768.                             seqEvent.type = SND_SEQ_EVENT_CONTROLLER;

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

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

  1771.                         }

  1772.                         break;

  1773.                     } // switch (ctrlEvent.type)

  1774.                     break;

  1775.                 } // case kEngineEventTypeControl

  1776. 

  1777.                 case kEngineEventTypeMidi: {

  1778.                     if (midiEventCount >= kPluginMaxMidiEvents)

  1779.                         continue;

  1780. 

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

  1782. 

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

  1784.                         continue;

  1785. 

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

  1787. 

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

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

  1790.                         status = MIDI_STATUS_NOTE_OFF;

  1791. 

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

  1793. 

  1794.                     seqEvent.time.tick = isSampleAccurate ? startTime : eventTime;

  1795. 

  1796.                     switch (status)

  1797.                     {

  1798.                     case MIDI_STATUS_NOTE_OFF: {

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

  1800. 

  1801.                         seqEvent.type = SND_SEQ_EVENT_NOTEOFF;

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

  1803.                         seqEvent.data.note.note    = note;

  1804. 

  1805.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff, true, event.channel, note, 0, 0.0f);

  1806.                         break;

  1807.                     }

  1808. 

  1809.                     case MIDI_STATUS_NOTE_ON: {

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

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

  1812. 

  1813.                         seqEvent.type = SND_SEQ_EVENT_NOTEON;

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

  1815.                         seqEvent.data.note.note     = note;

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

  1817. 

  1818.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn, true, event.channel, note, velo, 0.0f);

  1819.                         break;

  1820.                     }

  1821. 

  1822.                     case MIDI_STATUS_POLYPHONIC_AFTERTOUCH:

  1823.                         if (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH)

  1824.                         {

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

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

  1827. 

  1828.                             seqEvent.type = SND_SEQ_EVENT_KEYPRESS;

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

  1830.                             seqEvent.data.note.note     = note;

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

  1832.                         }

  1833.                         break;

  1834. 

  1835.                     case MIDI_STATUS_CONTROL_CHANGE:

  1836.                         if (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES)

  1837.                         {

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

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

  1840. 

  1841.                             seqEvent.type = SND_SEQ_EVENT_CONTROLLER;

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

  1843.                             seqEvent.data.control.param   = control;

  1844.                             seqEvent.data.control.value   = value;

  1845.                         }

  1846.                         break;

  1847. 

  1848.                     case MIDI_STATUS_CHANNEL_PRESSURE:

  1849.                         if (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE)

  1850.                         {

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

  1852. 

  1853.                             seqEvent.type = SND_SEQ_EVENT_CHANPRESS;

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

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

  1856.                         }

  1857.                         break;

  1858. 

  1859.                     case MIDI_STATUS_PITCH_WHEEL_CONTROL:

  1860.                         if (pData->options & PLUGIN_OPTION_SEND_PITCHBEND)

  1861.                         {

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

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

  1864. 

  1865.                             seqEvent.type = SND_SEQ_EVENT_PITCHBEND;

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

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

  1868.                         }

  1869.                         break;

  1870. 

  1871.                     default:

  1872.                         --midiEventCount;

  1873.                         break;

  1874.                     } // switch (status)

  1875.                 } break;

  1876.                 } // switch (event.type)

  1877.             }

  1878. 

  1879.             pData->postRtEvents.trySplice();

  1880. 

  1881.             if (frames > timeOffset)

  1882.                 processSingle(audioIn, audioOut, frames - timeOffset, timeOffset, midiEventCount);

  1883. 

  1884.         } // End of Event Input and Processing

  1885. 

  1886.         // --------------------------------------------------------------------------------------------------------

  1887.         // Plugin processing (no events)

  1888. 

  1889.         else

  1890.         {

  1891.             processSingle(audioIn, audioOut, frames, 0, midiEventCount);

  1892. 

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

  1894. 

  1895.         // --------------------------------------------------------------------------------------------------------

  1896.         // Control Output

  1897. 

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

  1899.         {

  1900.             uint8_t  channel;

  1901.             uint16_t param;

  1902.             float    value;

  1903. 

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

  1905.             {

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

  1907.                     continue;

  1908. 

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

  1910. 

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

  1912.                 {

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

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

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

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

  1917.                 }

  1918.             }

  1919.         } // End of Control Output

  1920.     }

  1921. 

  1922.     bool processSingle(const float** const audioIn, float** const audioOut, const uint32_t frames,

  1923.                        const uint32_t timeOffset, const ulong midiEventCount)

  1924.     {

  1925.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1926. 

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

  1928.         {

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

  1930.         }

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

  1932.         {

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

  1934.         }

  1935. 

  1936.         // --------------------------------------------------------------------------------------------------------

  1937.         // Try lock, silence otherwise

  1938. 

  1939. #ifndef STOAT_TEST_BUILD

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

  1941.         {

  1942.             pData->singleMutex.lock();

  1943.         }

  1944.         else

  1945. #endif

  1946.         if (! pData->singleMutex.tryLock())

  1947.         {

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

  1949.             {

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

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

  1952.             }

  1953. 

  1954.             return false;

  1955.         }

  1956. 

  1957.         // --------------------------------------------------------------------------------------------------------

  1958.         // Set audio buffers

  1959. 

  1960.         const bool customMonoOut   = pData->audioOut.count == 2 && fForcedStereoOut && ! fForcedStereoIn;

  1961.         const bool customStereoOut = pData->audioOut.count == 2 && fForcedStereoIn  && ! fForcedStereoOut;

  1962. 

  1963.         if (! customMonoOut)

  1964.         {

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

  1966.                 carla_zeroFloats(fAudioOutBuffers[i], frames);

  1967.         }

  1968. 

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

  1970.             carla_copyFloats(fAudioInBuffers[i], audioIn[i]+timeOffset, frames);

  1971. 

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

  1973.         // Run plugin

  1974. 

  1975.         uint instn = 0;

  1976.         for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next(), ++instn)

  1977.         {

  1978.             LADSPA_Handle const handle(it.getValue(nullptr));

  1979.             CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  1980. 

  1981.             // ----------------------------------------------------------------------------------------------------

  1982.             // Mixdown for forced stereo

  1983. 

  1984.             if (customMonoOut)

  1985.                 carla_zeroFloats(fAudioOutBuffers[instn], frames);

  1986. 

  1987.             // ----------------------------------------------------------------------------------------------------

  1988.             // Run it

  1989. 

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

  1991.             {

  1992.                 try {

  1993.                     fDssiDescriptor->run_synth(handle, frames, fMidiEvents, midiEventCount);

  1994.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI run_synth");

  1995.             }

  1996.             else

  1997.             {

  1998.                 try {

  1999.                     fDescriptor->run(handle, frames);

  2000.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI run");

  2001.             }

  2002. 

  2003.             // ----------------------------------------------------------------------------------------------------

  2004.             // Mixdown for forced stereo

  2005. 

  2006.             if (customMonoOut)

  2007.                 carla_multiply(fAudioOutBuffers[instn], 0.5f, frames);

  2008.             else if (customStereoOut)

  2009.                 carla_copyFloats(fExtraStereoBuffer[instn], fAudioOutBuffers[instn], frames);

  2010.         }

  2011. 

  2012.         if (customStereoOut)

  2013.         {

  2014.             carla_copyFloats(fAudioOutBuffers[0], fExtraStereoBuffer[0], frames);

  2015.             carla_copyFloats(fAudioOutBuffers[1], fExtraStereoBuffer[1], frames);

  2016.         }

  2017. 

  2018. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2019.         // --------------------------------------------------------------------------------------------------------

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

  2021. 

  2022.         {

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

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

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

  2026. 

  2027.             bool isPair;

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

  2029. 

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

  2031.             {

  2032.                 // Dry/Wet

  2033.                 if (doDryWet)

  2034.                 {

  2035.                     const uint32_t c = isMono ? 0 : i;

  2036. 

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

  2038.                     {

  2039. # ifndef BUILD_BRIDGE

  2040.                         if (k < pData->latency.frames && pData->latency.buffers != nullptr)

  2041.                             bufValue = pData->latency.buffers[c][k];

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

  2043.                             bufValue = fAudioInBuffers[c][k-pData->latency.frames];

  2044.                         else

  2045. # endif

  2046.                             bufValue = fAudioInBuffers[c][k];

  2047. 

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

  2049.                     }

  2050.                 }

  2051. 

  2052.                 // Balance

  2053.                 if (doBalance)

  2054.                 {

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

  2056. 

  2057.                     if (isPair)

  2058.                     {

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

  2060.                         carla_copyFloats(oldBufLeft, fAudioOutBuffers[i], frames);

  2061.                     }

  2062. 

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

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

  2065. 

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

  2067.                     {

  2068.                         if (isPair)

  2069.                         {

  2070.                             // left

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

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

  2073.                         }

  2074.                         else

  2075.                         {

  2076.                             // right

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

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

  2079.                         }

  2080.                     }

  2081.                 }

  2082. 

  2083.                 // Volume (and buffer copy)

  2084.                 {

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

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

  2087.                 }

  2088.             }

  2089. 

  2090.         } // End of Post-processing

  2091. 

  2092. # ifndef BUILD_BRIDGE

  2093.         // --------------------------------------------------------------------------------------------------------

  2094.         // Save latency values for next callback

  2095. 

  2096.         if (pData->latency.frames != 0 && pData->latency.buffers != nullptr)

  2097.         {

  2098.             CARLA_SAFE_ASSERT(timeOffset == 0);

  2099.             const uint32_t latframes = pData->latency.frames;

  2100. 

  2101.             if (latframes <= frames)

  2102.             {

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

  2104.                     carla_copyFloats(pData->latency.buffers[i], audioIn[i]+(frames-latframes), latframes);

  2105.             }

  2106.             else

  2107.             {

  2108.                 const uint32_t diff = latframes - frames;

  2109. 

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

  2111.                 {

  2112.                     // push back buffer by 'frames'

  2113.                     for (k=0; k < diff; ++k)

  2114.                         pData->latency.buffers[i][k] = pData->latency.buffers[i][k+frames];

  2115. 

  2116.                     // put current input at the end

  2117.                     for (uint32_t j=0; k < latframes; ++j, ++k)

  2118.                         pData->latency.buffers[i][k] = audioIn[i][j];

  2119.                 }

  2120.             }

  2121.         }

  2122. # endif

  2123. #else // BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2125.         {

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

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

  2128.         }

  2129. #endif

  2130. 

  2131.         // --------------------------------------------------------------------------------------------------------

  2132. 

  2133.         pData->singleMutex.unlock();

  2134.         return true;

  2135.     }

  2136. 

  2137.     void bufferSizeChanged(const uint32_t newBufferSize) override

  2138.     {

  2139.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  2140.         carla_debug("CarlaPluginLADSPADSSI::bufferSizeChanged(%i) - start", newBufferSize);

  2141. 

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

  2143.         {

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

  2145.                 delete[] fAudioInBuffers[i];

  2146. 

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

  2148.             carla_zeroFloats(fAudioInBuffers[i], newBufferSize);

  2149.         }

  2150. 

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

  2152.         {

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

  2154.                 delete[] fAudioOutBuffers[i];

  2155. 

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

  2157.             carla_zeroFloats(fAudioOutBuffers[i], newBufferSize);

  2158.         }

  2159. 

  2160.         if (fExtraStereoBuffer[0] != nullptr)

  2161.         {

  2162.             delete[] fExtraStereoBuffer[0];

  2163.             fExtraStereoBuffer[0] = nullptr;

  2164.         }

  2165. 

  2166.         if (fExtraStereoBuffer[1] != nullptr)

  2167.         {

  2168.             delete[] fExtraStereoBuffer[1];

  2169.             fExtraStereoBuffer[1] = nullptr;

  2170.         }

  2171. 

  2172.         if (fForcedStereoIn && pData->audioOut.count == 2)

  2173.         {

  2174.             fExtraStereoBuffer[0] = new float[newBufferSize];

  2175.             fExtraStereoBuffer[1] = new float[newBufferSize];

  2176.             carla_zeroFloats(fExtraStereoBuffer[0], newBufferSize);

  2177.             carla_zeroFloats(fExtraStereoBuffer[1], newBufferSize);

  2178.         }

  2179. 

  2180.         reconnectAudioPorts();

  2181. 

  2182.         carla_debug("CarlaPluginLADSPADSSI::bufferSizeChanged(%i) - end", newBufferSize);

  2183.     }

  2184. 

  2185.     void sampleRateChanged(const double newSampleRate) override

  2186.     {

  2187.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  2188.         carla_debug("CarlaPluginLADSPADSSI::sampleRateChanged(%g) - start", newSampleRate);

  2189. 

  2190.         // TODO - handle UI stuff

  2191. 

  2192.         if (pData->active)

  2193.             deactivate();

  2194. 

  2195.         const std::size_t instanceCount(fHandles.count());

  2196. 

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

  2198.         {

  2199.             for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  2200.             {

  2201.                 LADSPA_Handle const handle(it.getValue(nullptr));

  2202.                 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  2203. 

  2204.                 try {

  2205.                     fDescriptor->cleanup(handle);

  2206.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI cleanup");

  2207.             }

  2208.         }

  2209. 

  2210.         fHandles.clear();

  2211. 

  2212.         for (std::size_t i=0; i<instanceCount; ++i)

  2213.             addInstance();

  2214. 

  2215.         reconnectAudioPorts();

  2216. 

  2217.         if (pData->active)

  2218.             activate();

  2219. 

  2220.         carla_debug("CarlaPluginLADSPADSSI::sampleRateChanged(%g) - end", newSampleRate);

  2221.     }

  2222. 

  2223.     void reconnectAudioPorts() const noexcept

  2224.     {

  2225.         if (fForcedStereoIn)

  2226.         {

  2227.             if (LADSPA_Handle const handle = fHandles.getFirst(nullptr))

  2228.             {

  2229.                 try {

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

  2231.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (forced stereo input, first)");

  2232.             }

  2233. 

  2234.             if (LADSPA_Handle const handle = fHandles.getLast(nullptr))

  2235.             {

  2236.                 try {

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

  2238.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (forced stereo input, last)");

  2239.             }

  2240.         }

  2241.         else

  2242.         {

  2243.             for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  2244.             {

  2245.                 LADSPA_Handle const handle(it.getValue(nullptr));

  2246.                 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  2247. 

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

  2249.                 {

  2250.                     try {

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

  2252.                     } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (audio input)");

  2253.                 }

  2254.             }

  2255.         }

  2256. 

  2257.         if (fForcedStereoOut)

  2258.         {

  2259.             if (LADSPA_Handle const handle = fHandles.getFirst(nullptr))

  2260.             {

  2261.                 try {

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

  2263.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (forced stereo output, first)");

  2264.             }

  2265. 

  2266.             if (LADSPA_Handle const handle = fHandles.getLast(nullptr))

  2267.             {

  2268.                 try {

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

  2270.                 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (forced stereo output, last)");

  2271.             }

  2272.         }

  2273.         else

  2274.         {

  2275.             for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())

  2276.             {

  2277.                 LADSPA_Handle const handle(it.getValue(nullptr));

  2278.                 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);

  2279. 

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

  2281.                 {

  2282.                     try {

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

  2284.                     } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (audio output)");

  2285.                 }

  2286.             }

  2287.         }

  2288.     }

  2289. 

  2290.     // -------------------------------------------------------------------

  2291.     // Plugin buffers

  2292. 

  2293.     void clearBuffers() noexcept override

  2294.     {

  2295.         carla_debug("CarlaPluginLADSPADSSI::clearBuffers() - start");

  2296. 

  2297.         if (fAudioInBuffers != nullptr)

  2298.         {

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

  2300.             {

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

  2302.                 {

  2303.                     delete[] fAudioInBuffers[i];

  2304.                     fAudioInBuffers[i] = nullptr;

  2305.                 }

  2306.             }

  2307. 

  2308.             delete[] fAudioInBuffers;

  2309.             fAudioInBuffers = nullptr;

  2310.         }

  2311. 

  2312.         if (fAudioOutBuffers != nullptr)

  2313.         {

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

  2315.             {

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

  2317.                 {

  2318.                     delete[] fAudioOutBuffers[i];

  2319.                     fAudioOutBuffers[i] = nullptr;

  2320.                 }

  2321.             }

  2322. 

  2323.             delete[] fAudioOutBuffers;

  2324.             fAudioOutBuffers = nullptr;

  2325.         }

  2326. 

  2327.         if (fExtraStereoBuffer[0] != nullptr)

  2328.         {

  2329.             delete[] fExtraStereoBuffer[0];

  2330.             fExtraStereoBuffer[0] = nullptr;

  2331.         }

  2332. 

  2333.         if (fExtraStereoBuffer[1] != nullptr)

  2334.         {

  2335.             delete[] fExtraStereoBuffer[1];

  2336.             fExtraStereoBuffer[1] = nullptr;

  2337.         }

  2338. 

  2339.         if (fParamBuffers != nullptr)

  2340.         {

  2341.             delete[] fParamBuffers;

  2342.             fParamBuffers = nullptr;

  2343.         }

  2344. 

  2345.         CarlaPlugin::clearBuffers();

  2346. 

  2347.         carla_debug("CarlaPluginLADSPADSSI::clearBuffers() - end");

  2348.     }

  2349. 

  2350. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2351.     // -------------------------------------------------------------------

  2352.     // OSC stuff

  2353. 

  2354.     void handleOscMessage(const char* const method, const int argc, const void* const argvx, const char* const types, const lo_message msg) override

  2355.     {

  2356.         const lo_address source(lo_message_get_source(msg));

  2357.         CARLA_SAFE_ASSERT_RETURN(source != nullptr,);

  2358. 

  2359.         // protocol for DSSI UIs *must* be UDP

  2360.         CARLA_SAFE_ASSERT_RETURN(lo_address_get_protocol(source) == LO_UDP,);

  2361. 

  2362.         if (fOscData.source == nullptr)

  2363.         {

  2364.             // if no UI is registered yet only "configure" and "update" messages are valid

  2365.             CARLA_SAFE_ASSERT_RETURN(std::strcmp(method, "configure") == 0 || std::strcmp(method, "update") == 0,)

  2366.         }

  2367.         else

  2368.         {

  2369.             // make sure message source is the DSSI UI

  2370.             const char* const msghost = lo_address_get_hostname(source);

  2371.             const char* const msgport = lo_address_get_port(source);

  2372. 

  2373.             const char* const ourhost = lo_address_get_hostname(fOscData.source);

  2374.             const char* const ourport = lo_address_get_port(fOscData.source);

  2375. 

  2376.             CARLA_SAFE_ASSERT_RETURN(std::strcmp(msghost, ourhost) == 0,);

  2377.             CARLA_SAFE_ASSERT_RETURN(std::strcmp(msgport, ourport) == 0,);

  2378.         }

  2379. 

  2380.         const lo_arg* const* const argv(static_cast<const lo_arg* const*>(argvx));

  2381. 

  2382.         if (std::strcmp(method, "configure") == 0)

  2383.             return handleOscMessageConfigure(argc, argv, types);

  2384.         if (std::strcmp(method, "control") == 0)

  2385.             return handleOscMessageControl(argc, argv, types);

  2386.         if (std::strcmp(method, "program") == 0)

  2387.             return handleOscMessageProgram(argc, argv, types);

  2388.         if (std::strcmp(method, "midi") == 0)

  2389.             return handleOscMessageMIDI(argc, argv, types);

  2390.         if (std::strcmp(method, "update") == 0)

  2391.             return handleOscMessageUpdate(argc, argv, types, lo_message_get_source(msg));

  2392.         if (std::strcmp(method, "exiting") == 0)

  2393.             return handleOscMessageExiting();

  2394. 

  2395.         carla_stdout("CarlaPluginLADSPADSSI::handleOscMessage() - unknown method '%s'", method);

  2396.     }

  2397. 

  2398.     void handleOscMessageConfigure(const int argc, const lo_arg* const* const argv, const char* const types)

  2399.     {

  2400.         carla_debug("CarlaPluginLADSPADSSI::handleMsgConfigure()");

  2401.         CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(2, "ss");

  2402. 

  2403.         const char* const key   = (const char*)&argv[0]->s;

  2404.         const char* const value = (const char*)&argv[1]->s;

  2405. 

  2406.         setCustomData(CUSTOM_DATA_TYPE_STRING, key, value, false);

  2407.     }

  2408. 

  2409.     void handleOscMessageControl(const int argc, const lo_arg* const* const argv, const char* const types)

  2410.     {

  2411.         carla_debug("CarlaPluginLADSPADSSI::handleMsgControl()");

  2412.         CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(2, "if");

  2413. 

  2414.         const int32_t rindex = argv[0]->i;

  2415.         const float   value  = argv[1]->f;

  2416. 

  2417.         setParameterValueByRealIndex(rindex, value, false, true, true);

  2418.     }

  2419. 

  2420.     void handleOscMessageProgram(const int argc, const lo_arg* const* const argv, const char* const types)

  2421.     {

  2422.         carla_debug("CarlaPluginLADSPADSSI::handleMsgProgram()");

  2423.         CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(2, "ii");

  2424. 

  2425.         const int32_t bank    = argv[0]->i;

  2426.         const int32_t program = argv[1]->i;

  2427. 

  2428.         CARLA_SAFE_ASSERT_RETURN(bank >= 0,);

  2429.         CARLA_SAFE_ASSERT_RETURN(program >= 0,);

  2430. 

  2431.         setMidiProgramById(static_cast<uint32_t>(bank), static_cast<uint32_t>(program), false, true, true);

  2432.     }

  2433. 

  2434.     void handleOscMessageMIDI(const int argc, const lo_arg* const* const argv, const char* const types)

  2435.     {

  2436.         carla_debug("CarlaPluginLADSPADSSI::handleMsgMidi()");

  2437.         CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(1, "m");

  2438. 

  2439.         if (getMidiInCount() == 0)

  2440.         {

  2441.             carla_stderr("CarlaPluginLADSPADSSI::handleMsgMidi() - received midi when plugin has no midi inputs");

  2442.             return;

  2443.         }

  2444. 

  2445.         const uint8_t* const data = argv[0]->m;

  2446.         uint8_t status  = data[1];

  2447.         uint8_t channel = status & 0x0F;

  2448. 

  2449.         // Fix bad note-off

  2450.         if (MIDI_IS_STATUS_NOTE_ON(status) && data[3] == 0)

  2451.             status = MIDI_STATUS_NOTE_OFF;

  2452. 

  2453.         if (MIDI_IS_STATUS_NOTE_OFF(status))

  2454.         {

  2455.             const uint8_t note = data[2];

  2456. 

  2457.             CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2458. 

  2459.             sendMidiSingleNote(channel, note, 0, false, true, true);

  2460.         }

  2461.         else if (MIDI_IS_STATUS_NOTE_ON(status))

  2462.         {

  2463.             const uint8_t note = data[2];

  2464.             const uint8_t velo = data[3];

  2465. 

  2466.             CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2467.             CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2468. 

  2469.             sendMidiSingleNote(channel, note, velo, false, true, true);

  2470.         }

  2471.     }

  2472. 

  2473.     void handleOscMessageUpdate(const int argc, const lo_arg* const* const argv, const char* const types, const lo_address source)

  2474.     {

  2475.         carla_debug("CarlaPluginLADSPADSSI::handleMsgUpdate()");

  2476.         CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(1, "s");

  2477. 

  2478.         const char* const url = (const char*)&argv[0]->s;

  2479. 

  2480.         // FIXME - remove debug prints later

  2481.         carla_stdout("CarlaPluginLADSPADSSI::updateOscData(%p, \"%s\")", source, url);

  2482. 

  2483.         fOscData.clear();

  2484. 

  2485.         const int proto = lo_address_get_protocol(source);

  2486. 

  2487.         {

  2488.             const char* host = lo_address_get_hostname(source);

  2489.             const char* port = lo_address_get_port(source);

  2490.             fOscData.source = lo_address_new_with_proto(proto, host, port);

  2491. 

  2492.             carla_stdout("CarlaPlugin::updateOscData() - source: host \"%s\", port \"%s\"", host, port);

  2493.         }

  2494. 

  2495.         {

  2496.             char* host = lo_url_get_hostname(url);

  2497.             char* port = lo_url_get_port(url);

  2498.             fOscData.path   = carla_strdup_free(lo_url_get_path(url));

  2499.             fOscData.target = lo_address_new_with_proto(proto, host, port);

  2500.             carla_stdout("CarlaPlugin::updateOscData() - target: host \"%s\", port \"%s\", path \"%s\"", host, port, fOscData.path);

  2501. 

  2502.             std::free(host);

  2503.             std::free(port);

  2504.         }

  2505. 

  2506.         osc_send_sample_rate(fOscData, static_cast<float>(pData->engine->getSampleRate()));

  2507. 

  2508.         for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())

  2509.         {

  2510.             const CustomData& customData(it.getValue(kCustomDataFallback));

  2511.             CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  2512. 

  2513.             if (std::strcmp(customData.type, CUSTOM_DATA_TYPE_STRING) == 0)

  2514.                 osc_send_configure(fOscData, customData.key, customData.value);

  2515.         }

  2516. 

  2517.         if (pData->prog.current >= 0)

  2518.             osc_send_program(fOscData, static_cast<uint32_t>(pData->prog.current));

  2519. 

  2520.         if (pData->midiprog.current >= 0)

  2521.         {

  2522.             const MidiProgramData& curMidiProg(pData->midiprog.getCurrent());

  2523.             osc_send_program(fOscData, curMidiProg.bank, curMidiProg.program);

  2524.         }

  2525. 

  2526.         for (uint32_t i=0; i < pData->param.count; ++i)

  2527.             osc_send_control(fOscData, pData->param.data[i].rindex, getParameterValue(i));

  2528. 

  2529. #ifndef BUILD_BRIDGE

  2530.         if (pData->engine->getOptions().frontendWinId != 0)

  2531.             pData->transientTryCounter = 1;

  2532. #endif

  2533. 

  2534.         carla_stdout("CarlaPluginLADSPADSSI::updateOscData() - done");

  2535.     }

  2536. 

  2537.     void handleOscMessageExiting()

  2538.     {

  2539.         carla_debug("CarlaPluginLADSPADSSI::handleMsgExiting()");

  2540. 

  2541.         // hide UI

  2542.         showCustomUI(false);

  2543. 

  2544.         // tell frontend

  2545.         pData->engine->callback(true, true,

  2546.                                 ENGINE_CALLBACK_UI_STATE_CHANGED,

  2547.                                 pData->id,

  2548.                                 0,

  2549.                                 0, 0, 0.0f, nullptr);

  2550.     }

  2551. 

  2552.     // -------------------------------------------------------------------

  2553.     // Post-poned UI Stuff

  2554. 

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

  2556.     {

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

  2558. 

  2559.         if (fOscData.target == nullptr)

  2560.             return;

  2561. 

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

  2563.     }

  2564. 

  2565.     void uiMidiProgramChange(const uint32_t index) noexcept override

  2566.     {

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

  2568. 

  2569.         if (fOscData.target == nullptr)

  2570.             return;

  2571. 

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

  2573.     }

  2574. 

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

  2576.     {

  2577.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2578.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  2580. 

  2581.         if (fOscData.target == nullptr)

  2582.             return;

  2583. 

  2584. #if 0

  2585.         uint8_t midiData[4];

  2586.         midiData[0] = 0;

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

  2588.         midiData[2] = note;

  2589.         midiData[3] = velo;

  2590. 

  2591.         osc_send_midi(fOscData, midiData);

  2592. #endif

  2593.     }

  2594. 

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

  2596.     {

  2597.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2598.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2599. 

  2600.         if (fOscData.target == nullptr)

  2601.             return;

  2602. 

  2603. #if 0

  2604.         uint8_t midiData[4];

  2605.         midiData[0] = 0;

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

  2607.         midiData[2] = note;

  2608.         midiData[3] = 0;

  2609. 

  2610.         osc_send_midi(fOscData, midiData);

  2611. #endif

  2612.     }

  2613. #endif // HAVE_LIBLO && !BUILD_BRIDGE

  2614. 

  2615.     // -------------------------------------------------------------------

  2616. 

  2617.     const void* getNativeDescriptor() const noexcept override

  2618.     {

  2619.         return fDssiDescriptor != nullptr

  2620.                ? (const void*)fDssiDescriptor

  2621.                : (const void*)fDescriptor;

  2622.     }

  2623. 

  2624.     const void* getExtraStuff() const noexcept override

  2625.     {

  2626.         if (fDssiDescriptor != nullptr)

  2627.         {

  2628. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2629.             return fUiFilename;

  2630. #else

  2631.             return nullptr;

  2632. #endif

  2633.         }

  2634.         return fRdfDescriptor;

  2635.     }

  2636. 

  2637. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2638.     uintptr_t getUiBridgeProcessId() const noexcept override

  2639.     {

  2640.         return fThreadUI.getProcessId();

  2641.     }

  2642. #endif

  2643. 

  2644.     // -------------------------------------------------------------------

  2645. 

  2646.     bool initLADSPA(const char* const filename, const char* name, const char* const label, const uint options,

  2647.                     const LADSPA_RDF_Descriptor* const rdfDescriptor)

  2648.     {

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

  2650. 

  2651.         // ---------------------------------------------------------------

  2652.         // first checks

  2653. 

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

  2655.         {

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

  2657.             return false;

  2658.         }

  2659. 

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

  2661.         {

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

  2663.             return false;

  2664.         }

  2665. 

  2666.         // ---------------------------------------------------------------

  2667.         // open DLL

  2668. 

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

  2670.         {

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

  2672.             return false;

  2673.         }

  2674. 

  2675.         // ---------------------------------------------------------------

  2676.         // get DLL main entry

  2677. 

  2678.         const LADSPA_Descriptor_Function descFn = pData->libSymbol<LADSPA_Descriptor_Function>("ladspa_descriptor");

  2679. 

  2680.         if (descFn == nullptr)

  2681.         {

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

  2683.             return false;

  2684.         }

  2685. 

  2686.         // ---------------------------------------------------------------

  2687.         // get descriptor that matches label

  2688. 

  2689.         // if label is null, get first valid plugin

  2690.         const bool nullLabel = (label == nullptr || label[0] == '\0');

  2691. 

  2692.         for (ulong d=0;; ++d)

  2693.         {

  2694.             try {

  2695.                 fDescriptor = descFn(d);

  2696.             }

  2697.             catch(...) {

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

  2699.                 fDescriptor = nullptr;

  2700.                 break;

  2701.             }

  2702. 

  2703.             if (fDescriptor == nullptr)

  2704.                 break;

  2705. 

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

  2707.             {

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

  2709.                 fDescriptor = nullptr;

  2710.                 break;

  2711.             }

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

  2713.             {

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

  2715.                 fDescriptor = nullptr;

  2716.                 break;

  2717.             }

  2718. 

  2719.             if (nullLabel || std::strcmp(fDescriptor->Label, label) == 0)

  2720.                 break;

  2721.         }

  2722. 

  2723.         if (fDescriptor == nullptr)

  2724.         {

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

  2726.             return false;

  2727.         }

  2728. 

  2729.         return init2(filename, name, options, rdfDescriptor);

  2730.     }

  2731. 

  2732.     bool initDSSI(const char* const filename, const char* name, const char* const label, const uint options)

  2733.     {

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

  2735. 

  2736.         // ---------------------------------------------------------------

  2737.         // first checks

  2738. 

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

  2740.         {

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

  2742.             return false;

  2743.         }

  2744. 

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

  2746.         {

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

  2748.             return false;

  2749.         }

  2750. 

  2751.         // ---------------------------------------------------------------

  2752.         // open DLL

  2753. 

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

  2755.         {

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

  2757.             return false;

  2758.         }

  2759. 

  2760.         // ---------------------------------------------------------------

  2761.         // get DLL main entry

  2762. 

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

  2764. 

  2765.         if (descFn == nullptr)

  2766.         {

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

  2768.             return false;

  2769.         }

  2770. 

  2771.         // ---------------------------------------------------------------

  2772.         // get descriptor that matches label

  2773. 

  2774.         // if label is null, get first valid plugin

  2775.         const bool nullLabel = (label == nullptr || label[0] == '\0');

  2776. 

  2777.         for (ulong d=0;; ++d)

  2778.         {

  2779.             try {

  2780.                 fDssiDescriptor = descFn(d);

  2781.             }

  2782.             catch(...) {

  2783.                 carla_stderr2("Caught exception when trying to get DSSI descriptor");

  2784.                 fDescriptor     = nullptr;

  2785.                 fDssiDescriptor = nullptr;

  2786.                 break;

  2787.             }

  2788. 

  2789.             if (fDssiDescriptor == nullptr)

  2790.                 break;

  2791. 

  2792.             fDescriptor = fDssiDescriptor->LADSPA_Plugin;

  2793. 

  2794.             if (fDescriptor == nullptr)

  2795.             {

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

  2797.                 fDssiDescriptor = nullptr;

  2798.                 break;

  2799.             }

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

  2801.             {

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

  2803.                 fDescriptor     = nullptr;

  2804.                 fDssiDescriptor = nullptr;

  2805.                 break;

  2806.             }

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

  2808.             {

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

  2810.                 fDescriptor     = nullptr;

  2811.                 fDssiDescriptor = nullptr;

  2812.                 break;

  2813.             }

  2814. 

  2815.             if (nullLabel || std::strcmp(fDescriptor->Label, label) == 0)

  2816.                 break;

  2817.         }

  2818. 

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

  2820.         {

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

  2822.             return false;

  2823.         }

  2824. 

  2825.         // ---------------------------------------------------------------

  2826.         // check if uses global instance

  2827. 

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

  2829.         {

  2830.             pData->engine->setLastError("This plugin requires run_multiple_synths which is not supported");

  2831.             return false;

  2832.         }

  2833. 

  2834.         return init2(filename, name, options, nullptr);

  2835.     }

  2836. 

  2837.     bool init2(const char* const filename, const char* name, const uint options,

  2838.                const LADSPA_RDF_Descriptor* const rdfDescriptor)

  2839.     {

  2840.         // ---------------------------------------------------------------

  2841.         // check for fixed buffer size requirement

  2842. 

  2843.         fNeedsFixedBuffers = CarlaString(filename).contains("dssi-vst", true);

  2844. 

  2845.         if (fNeedsFixedBuffers && ! pData->engine->usesConstantBufferSize())

  2846.         {

  2847.             pData->engine->setLastError("Cannot use this plugin under the current engine.\n"

  2848.                                         "The plugin requires a fixed block size which is not possible right now.");

  2849.             return false;

  2850.         }

  2851. 

  2852.         // ---------------------------------------------------------------

  2853.         // get info

  2854. 

  2855.         if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))

  2856.             fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);

  2857. 

  2858.         if (name == nullptr || name[0] == '\0')

  2859.         {

  2860.             /**/ if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr && fRdfDescriptor->Title[0] != '\0')

  2861.                 name = fRdfDescriptor->Title;

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

  2863.                 name = fDescriptor->Name;

  2864.             else

  2865.                 name = fDescriptor->Label;

  2866.         }

  2867. 

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

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

  2870. 

  2871.         // ---------------------------------------------------------------

  2872.         // register client

  2873. 

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

  2875. 

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

  2877.         {

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

  2879.             return false;

  2880.         }

  2881. 

  2882.         // ---------------------------------------------------------------

  2883.         // initialize plugin

  2884. 

  2885.         if (! addInstance())

  2886.             return false;

  2887. 

  2888.         // ---------------------------------------------------------------

  2889.         // find latency port index

  2890. 

  2891.         for (uint32_t i=0, iCtrl=0, count=getSafePortCount(); i<count; ++i)

  2892.         {

  2893.             const int portType(fDescriptor->PortDescriptors[i]);

  2894. 

  2895.             if (! LADSPA_IS_PORT_CONTROL(portType))

  2896.                 continue;

  2897. 

  2898.             const uint32_t index(iCtrl++);

  2899. 

  2900.             if (! LADSPA_IS_PORT_OUTPUT(portType))

  2901.                 continue;

  2902. 

  2903.             const char* const portName(fDescriptor->PortNames[i]);

  2904.             CARLA_SAFE_ASSERT_BREAK(portName != nullptr);

  2905. 

  2906.             if (std::strcmp(portName, "latency")  == 0 ||

  2907.                 std::strcmp(portName, "_latency") == 0)

  2908.             {

  2909.                 fLatencyIndex = static_cast<int32_t>(index);

  2910.                 break;

  2911.             }

  2912.         }

  2913. 

  2914.         // ---------------------------------------------------------------

  2915.         // check for custom data extension

  2916. 

  2917.         if (fDssiDescriptor != nullptr && fDssiDescriptor->configure != nullptr)

  2918.         {

  2919.             if (char* const error = fDssiDescriptor->configure(fHandles.getFirst(nullptr), DSSI_CUSTOMDATA_EXTENSION_KEY, ""))

  2920.             {

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

  2922.                                                     && fDssiDescriptor->set_custom_data != nullptr)

  2923.                     fUsesCustomData = true;

  2924. 

  2925.                 std::free(error);

  2926.             }

  2927.         }

  2928. 

  2929.         // ---------------------------------------------------------------

  2930.         // get engine options

  2931. 

  2932.         const EngineOptions& opts(pData->engine->getOptions());

  2933. 

  2934. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2935.         // ---------------------------------------------------------------

  2936.         // check for gui

  2937. 

  2938.         if (opts.oscEnabled && opts.oscPortUDP >= 0)

  2939.         {

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

  2941.             {

  2942.                 fUiFilename = guiFilename;

  2943.                 fThreadUI.setData(guiFilename, fDescriptor->Label);

  2944.             }

  2945.         }

  2946. #endif

  2947. 

  2948.         // ---------------------------------------------------------------

  2949.         // set default options

  2950. 

  2951.         pData->options = 0x0;

  2952. 

  2953.         /**/ if (fLatencyIndex >= 0 || fNeedsFixedBuffers)

  2954.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  2955.         else if (options & PLUGIN_OPTION_FIXED_BUFFERS)

  2956.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  2957. 

  2958.         /**/ if (opts.forceStereo)

  2959.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  2960.         else if (options & PLUGIN_OPTION_FORCE_STEREO)

  2961.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  2962. 

  2963.         if (fDssiDescriptor != nullptr)

  2964.         {

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

  2966.                 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2967. 

  2968.             if (fUsesCustomData)

  2969.                 pData->options |= PLUGIN_OPTION_USE_CHUNKS;

  2970. 

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

  2972.             {

  2973.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2974.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2975.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  2976.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2977. 

  2978.                 if (options & PLUGIN_OPTION_SEND_CONTROL_CHANGES)

  2979.                     pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  2980.             }

  2981.         }

  2982. 

  2983.         return true;

  2984.     }

  2985. 

  2986.     // -------------------------------------------------------------------

  2987. 

  2988. private:

  2989.     LinkedList<LADSPA_Handle>    fHandles;

  2990.     const LADSPA_Descriptor*     fDescriptor;

  2991.     const DSSI_Descriptor*       fDssiDescriptor;

  2992.     const LADSPA_RDF_Descriptor* fRdfDescriptor;

  2993. 

  2994.     float** fAudioInBuffers;

  2995.     float** fAudioOutBuffers;

  2996.     float*  fExtraStereoBuffer[2]; // used only if forcedStereoIn and audioOut == 2

  2997.     float*  fParamBuffers;

  2998. 

  2999.     snd_seq_event_t fMidiEvents[kPluginMaxMidiEvents];

  3000. 

  3001.     int32_t fLatencyIndex; // -1 if invalid

  3002.     bool    fForcedStereoIn;

  3003.     bool    fForcedStereoOut;

  3004.     bool    fNeedsFixedBuffers;

  3005.     bool    fUsesCustomData;

  3006. 

  3007. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  3008.     CarlaOscData      fOscData;

  3009.     CarlaThreadDSSIUI fThreadUI;

  3010.     const char*       fUiFilename;

  3011. #endif

  3012. 

  3013.     // -------------------------------------------------------------------

  3014. 

  3015.     bool addInstance()

  3016.     {

  3017.         LADSPA_Handle handle;

  3018. 

  3019.         try {

  3020.             handle = fDescriptor->instantiate(fDescriptor, static_cast<ulong>(pData->engine->getSampleRate()));

  3021.         } CARLA_SAFE_EXCEPTION_RETURN_ERR("LADSPA/DSSI instantiate", "Plugin failed to initialize");

  3022. 

  3023.         for (uint32_t i=0, count=pData->param.count; i<count; ++i)

  3024.         {

  3025.             const int32_t rindex(pData->param.data[i].rindex);

  3026.             CARLA_SAFE_ASSERT_CONTINUE(rindex >= 0);

  3027. 

  3028.             try {

  3029.                 fDescriptor->connect_port(handle, static_cast<ulong>(rindex), &fParamBuffers[i]);

  3030.             } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port");

  3031.         }

  3032. 

  3033.         if (fHandles.append(handle))

  3034.             return true;

  3035. 

  3036.         try {

  3037.             fDescriptor->cleanup(handle);

  3038.         } CARLA_SAFE_EXCEPTION("LADSPA/DSSI cleanup");

  3039. 

  3040.         pData->engine->setLastError("Out of memory");

  3041.         return false;

  3042.     }

  3043. 

  3044.     uint32_t getSafePortCount() const noexcept

  3045.     {

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

  3047.             return 0;

  3048. 

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

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

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

  3052. 

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

  3054.     }

  3055. 

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

  3057.     {

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

  3059.             return true;

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

  3061.             return true;

  3062.         return false;

  3063.     }

  3064. 

  3065.     static bool _getSeparatedParameterNameOrUnitImpl(const char* const paramName, char* const strBuf,

  3066.                                                      const bool wantName, const bool useBracket) noexcept

  3067.     {

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

  3069. 

  3070.         if (sepBracketStart == nullptr)

  3071.             return false;

  3072. 

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

  3074. 

  3075.         if (sepBracketEnd == nullptr)

  3076.             return false;

  3077. 

  3078.         const std::size_t unitSize(static_cast<std::size_t>(sepBracketEnd-sepBracketStart-2));

  3079. 

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

  3081.             return false;

  3082. 

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

  3084. 

  3085.         // just in case

  3086.         if (sepIndex+2 >= STR_MAX)

  3087.             return false;

  3088. 

  3089.         if (wantName)

  3090.         {

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

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

  3093.         }

  3094.         else

  3095.         {

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

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

  3098.         }

  3099. 

  3100.         return true;

  3101.     }

  3102. 

  3103.     // -------------------------------------------------------------------

  3104. 

  3105.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginLADSPADSSI)

  3106. };

  3107. 

  3108. // -------------------------------------------------------------------------------------------------------------------

  3109. 

  3110. CarlaPlugin* CarlaPlugin::newLADSPA(const Initializer& init, const LADSPA_RDF_Descriptor* const rdfDescriptor)

  3111. {

  3112.     carla_debug("CarlaPlugin::newLADSPA({%p, \"%s\", \"%s\", \"%s\", " P_INT64 ", %x}, %p)",

  3113.                 init.engine, init.filename, init.name, init.label, init.uniqueId, init.options, rdfDescriptor);

  3114. 

  3115.     CarlaPluginLADSPADSSI* const plugin(new CarlaPluginLADSPADSSI(init.engine, init.id));

  3116. 

  3117.     if (! plugin->initLADSPA(init.filename, init.name, init.label, init.options, rdfDescriptor))

  3118.     {

  3119.         delete plugin;

  3120.         return nullptr;

  3121.     }

  3122. 

  3123.     return plugin;

  3124. }

  3125. 

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

  3127. {

  3128.     carla_debug("CarlaPlugin::newDSSI({%p, \"%s\", \"%s\", \"%s\", " P_INT64 ", %x})",

  3129.                 init.engine, init.filename, init.name, init.label, init.uniqueId, init.options);

  3130. 

  3131.     CarlaPluginLADSPADSSI* const plugin(new CarlaPluginLADSPADSSI(init.engine, init.id));

  3132. 

  3133.     if (! plugin->initDSSI(init.filename, init.name, init.label, init.options))

  3134.     {

  3135.         delete plugin;

  3136.         return nullptr;

  3137.     }

  3138. 

  3139.     return plugin;

  3140. }

  3141. 

  3142. // -------------------------------------------------------------------------------------------------------------------

  3143. 

  3144. CARLA_BACKEND_END_NAMESPACE