falkTX
/
Carla-Plugins
mirror of https://github.com/falkTX/Carla-Plugins
1
0
Fork 0
Code Releases 0 Activity
External plugins for 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.
25 Commits
2 Branches
11MB
Tree: 04544c5446
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '04544c5446'
${ noResults }
Carla-Plugins/zynaddsubfx-fx.cpp

1506 lines
45KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2022 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 "CarlaNative.hpp"

  19. #include "CarlaMathUtils.hpp"

  20. 

  21. #if defined(__clang__)

  22. # pragma clang diagnostic push

  23. # pragma clang diagnostic ignored "-Weffc++"

  24. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  25. # pragma GCC diagnostic push

  26. # pragma GCC diagnostic ignored "-Weffc++"

  27. # pragma GCC diagnostic ignored "-Wconversion"

  28. # pragma GCC diagnostic ignored "-Wnon-virtual-dtor"

  29. # pragma GCC diagnostic ignored "-Wsign-conversion"

  30. # pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"

  31. #endif

  32. 

  33. #include "Misc/Allocator.h"

  34. #include "Effects/Alienwah.h"

  35. #include "Effects/Chorus.h"

  36. #include "Effects/Distorsion.h"

  37. #include "Effects/DynamicFilter.h"

  38. #include "Effects/Echo.h"

  39. #include "Effects/Phaser.h"

  40. #include "Effects/Reverb.h"

  41. 

  42. #if defined(__clang__)

  43. # pragma clang diagnostic pop

  44. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  45. # pragma GCC diagnostic pop

  46. #endif

  47. 

  48. #include "water/maths/MathsFunctions.h"

  49. 

  50. using water::roundToIntAccurate;

  51. 

  52. using namespace zyncarla;

  53. 

  54. // -----------------------------------------------------------------------

  55. 

  56. template<class ZynFX>

  57. class FxAbstractPlugin : public NativePluginClass

  58. {

  59. protected:

  60.     FxAbstractPlugin(const NativeHostDescriptor* const host, const uint32_t paramCount, const uint32_t programCount)

  61.         : NativePluginClass(host),

  62.           fParamCount(paramCount-2), // volume and pan handled by host

  63.           fProgramCount(programCount),

  64.           fParamValues(new uchar[paramCount]),

  65.           fParamsChanged(new bool[paramCount]),

  66.           fNextProgram(-1),

  67.           fBufferSize(getBufferSize()),

  68.           fSampleRate(getSampleRate()),

  69.           fFilterParams(nullptr),

  70.           fEffect(nullptr),

  71.           efxoutl(nullptr),

  72.           efxoutr(nullptr),

  73.           fAllocator()

  74.     {

  75.         efxoutl = new float[fBufferSize];

  76.         efxoutr = new float[fBufferSize];

  77.         carla_zeroFloats(efxoutl, fBufferSize);

  78.         carla_zeroFloats(efxoutr, fBufferSize);

  79. 

  80.         std::memset(fParamsChanged, 0, sizeof(bool)*fParamCount);

  81. 

  82.         doReinit(true);

  83.     }

  84. 

  85.     ~FxAbstractPlugin() override

  86.     {

  87.         if (efxoutl != nullptr)

  88.         {

  89.             delete[] efxoutl;

  90.             efxoutl = nullptr;

  91.         }

  92. 

  93.         if (efxoutr != nullptr)

  94.         {

  95.             delete[] efxoutr;

  96.             efxoutr = nullptr;

  97.         }

  98. 

  99.         if (fEffect != nullptr)

  100.         {

  101.             delete fEffect;

  102.             fEffect = nullptr;

  103.         }

  104.     }

  105. 

  106.     // -------------------------------------------------------------------

  107.     // Plugin parameter calls

  108. 

  109.     uint32_t getParameterCount() const final

  110.     {

  111.         return fParamCount;

  112.     }

  113. 

  114.     float getParameterValue(const uint32_t index) const final

  115.     {

  116.         return static_cast<float>(fEffect->getpar(static_cast<int>(index+2)));

  117.     }

  118. 

  119.     // -------------------------------------------------------------------

  120.     // Plugin midi-program calls

  121. 

  122.     uint32_t getMidiProgramCount() const final

  123.     {

  124.         return fProgramCount;

  125.     }

  126. 

  127.     // -------------------------------------------------------------------

  128.     // Plugin state calls

  129. 

  130.     void setParameterValue(const uint32_t index, const float value) final

  131.     {

  132.         const int ivalue(roundToIntAccurate(carla_fixedValue(0.0f, 127.0f, value)));

  133. 

  134.         fParamValues[index] = static_cast<uchar>(ivalue);

  135.         fParamsChanged[index] = true;

  136.     }

  137. 

  138.     void setMidiProgram(const uint8_t, const uint32_t, const uint32_t program) final

  139.     {

  140.         fNextProgram = static_cast<int32_t>(program);

  141.     }

  142. 

  143.     // -------------------------------------------------------------------

  144.     // Plugin process calls

  145. 

  146.     void activate() final

  147.     {

  148.         fEffect->cleanup();

  149.     }

  150. 

  151.     void process(const float* const* const inBuffer, float** const outBuffer, const uint32_t frames,

  152.                  const NativeMidiEvent* const, const uint32_t) final

  153.     {

  154.         if (outBuffer[0] != inBuffer[0])

  155.             carla_copyWithMultiply(outBuffer[0], inBuffer[0], 0.5f, frames);

  156.         else

  157.             carla_multiply(outBuffer[0], 0.5f, frames);

  158. 

  159.         if (outBuffer[1] != inBuffer[1])

  160.             carla_copyWithMultiply(outBuffer[1], inBuffer[1], 0.5f, frames);

  161.         else

  162.             carla_multiply(outBuffer[1], 0.5f, frames);

  163. 

  164.         const int32_t nextProgram = fNextProgram;

  165.         fNextProgram = -1;

  166. 

  167.         if (nextProgram >= 0)

  168.         {

  169.             fEffect->setpreset(static_cast<uchar>(nextProgram));

  170. 

  171.             // reset volume and pan

  172.             fEffect->changepar(0, 127);

  173.             fEffect->changepar(1, 64);

  174. 

  175.             // ignore next

  176.             std::memset(fParamsChanged, 0, sizeof(bool)*fParamCount);

  177.         }

  178.         else

  179.         {

  180.             for (int i=0, count=static_cast<int>(fParamCount); i<count; ++i)

  181.             {

  182.                 if (! fParamsChanged[i])

  183.                     continue;

  184. 

  185.                 fEffect->changepar(i+2, fParamValues[i]);

  186.                 fParamsChanged[i] = false;

  187.             }

  188.         }

  189. 

  190.         // FIXME

  191.         fEffect->out(Stereo<float*>(const_cast<float*>(inBuffer[0]),

  192.                                     const_cast<float*>(inBuffer[1])));

  193. 

  194.         carla_addWithMultiply(outBuffer[0], efxoutl, 0.5f, frames);

  195.         carla_addWithMultiply(outBuffer[1], efxoutr, 0.5f, frames);

  196.     }

  197. 

  198.     // -------------------------------------------------------------------

  199.     // Plugin dispatcher

  200. 

  201.     void bufferSizeChanged(const uint32_t bufferSize) final

  202.     {

  203.         if (fBufferSize == bufferSize)

  204.             return;

  205. 

  206.         fBufferSize = bufferSize;

  207. 

  208.         delete[] efxoutl;

  209.         delete[] efxoutr;

  210.         efxoutl = new float[bufferSize];

  211.         efxoutr = new float[bufferSize];

  212.         carla_zeroFloats(efxoutl, bufferSize);

  213.         carla_zeroFloats(efxoutr, bufferSize);

  214. 

  215.         doReinit(false);

  216.     }

  217. 

  218.     void sampleRateChanged(const double sampleRate) final

  219.     {

  220.         if (carla_isEqual(fSampleRate, sampleRate))

  221.             return;

  222. 

  223.         fSampleRate = sampleRate;

  224. 

  225.         doReinit(false);

  226.     }

  227. 

  228.     void doReinit(const bool firstInit)

  229.     {

  230.         uchar params[fParamCount];

  231. 

  232.         if (fEffect != nullptr)

  233.         {

  234.             for (int i=0, count=static_cast<int>(fParamCount); i<count; ++i)

  235.                 params[i] = fEffect->getpar(i+2);

  236. 

  237.             delete fEffect;

  238.         }

  239. 

  240.         EffectParams pars(fAllocator, false, efxoutl, efxoutr, 0,

  241.                           static_cast<uint>(fSampleRate), static_cast<int>(fBufferSize), &fFilterParams);

  242. 

  243.         fEffect = new ZynFX(pars);

  244. 

  245.         if (firstInit)

  246.         {

  247.             fEffect->setpreset(0);

  248. 

  249.             for (int i=0, count=static_cast<int>(fParamCount); i<count; ++i)

  250.                 fParamValues[i] = fEffect->getpar(i+2);

  251.         }

  252.         else

  253.         {

  254.             for (int i=0, count=static_cast<int>(fParamCount); i<count; ++i)

  255.                 fEffect->changepar(i+2, params[i]);

  256.         }

  257. 

  258.         // reset volume and pan

  259.         fEffect->changepar(0, 127);

  260.         fEffect->changepar(1, 64);

  261.     }

  262. 

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

  264. 

  265.     const uint32_t fParamCount;

  266.     const uint32_t fProgramCount;

  267. 

  268.     uchar* const fParamValues;

  269.     bool*  const fParamsChanged;

  270.     int32_t      fNextProgram;

  271. 

  272.     uint32_t fBufferSize;

  273.     double   fSampleRate;

  274. 

  275.     FilterParams fFilterParams;

  276.     Effect* fEffect;

  277.     float*  efxoutl;

  278.     float*  efxoutr;

  279. 

  280.     AllocatorClass fAllocator;

  281. 

  282.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  283. };

  284. 

  285. // -----------------------------------------------------------------------

  286. 

  287. class FxAlienWahPlugin : public FxAbstractPlugin<Alienwah>

  288. {

  289. public:

  290.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

  291.         : FxAbstractPlugin(host, 11, 4) {}

  292. 

  293. protected:

  294.     // -------------------------------------------------------------------

  295.     // Plugin parameter calls

  296. 

  297.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  298.     {

  299.         if (index >= fParamCount)

  300.             return nullptr;

  301. 

  302.         static NativeParameter param;

  303.         static NativeParameterScalePoint scalePoints[2];

  304. 

  305.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  306. 

  307.         param.name = nullptr;

  308.         param.unit = nullptr;

  309.         param.ranges.def       = 1.0f;

  310.         param.ranges.min       = 0.0f;

  311.         param.ranges.max       = 127.0f;

  312.         param.ranges.step      = 1.0f;

  313.         param.ranges.stepSmall = 1.0f;

  314.         param.ranges.stepLarge = 20.0f;

  315.         param.scalePointCount  = 0;

  316.         param.scalePoints      = nullptr;

  317. 

  318.         switch (index)

  319.         {

  320.         case 0:

  321.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  322.             param.name = "LFO Frequency";

  323.             param.ranges.def = 70.0f;

  324.             break;

  325.         case 1:

  326.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  327.             param.name = "LFO Randomness";

  328.             param.ranges.def = 0.0f;

  329.             break;

  330.         case 2:

  331.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  332.             param.name = "LFO Type";

  333.             param.ranges.def = 0.0f;

  334.             param.ranges.max = 1.0f;

  335.             param.scalePointCount = 2;

  336.             param.scalePoints     = scalePoints;

  337.             scalePoints[0].label  = "Sine";

  338.             scalePoints[1].label  = "Triangle";

  339.             scalePoints[0].value  = 0.0f;

  340.             scalePoints[1].value  = 1.0f;

  341.             break;

  342.         case 3:

  343.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  344.             param.name = "LFO Stereo";

  345.             param.ranges.def = 62.0f;

  346.             break;

  347.         case 4:

  348.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  349.             param.name = "Depth";

  350.             param.ranges.def = 60.0f;

  351.             break;

  352.         case 5:

  353.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  354.             param.name = "Feedback";

  355.             param.ranges.def = 105.0f;

  356.             break;

  357.         case 6:

  358.             param.name = "Delay";

  359.             param.ranges.def = 25.0f;

  360.             param.ranges.min = 1.0f;

  361.             param.ranges.max = 100.0f;

  362.             break;

  363.         case 7:

  364.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  365.             param.name = "L/R Cross";

  366.             param.ranges.def = 0.0f;

  367.             break;

  368.         case 8:

  369.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  370.             param.name = "Phase";

  371.             param.ranges.def = 64.0f;

  372.             break;

  373.         }

  374. 

  375.         param.hints = static_cast<NativeParameterHints>(hints);

  376. 

  377.         return &param;

  378.     }

  379. 

  380.     // -------------------------------------------------------------------

  381.     // Plugin midi-program calls

  382. 

  383.     const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const override

  384.     {

  385.         if (index >= fProgramCount)

  386.             return nullptr;

  387. 

  388.         static NativeMidiProgram midiProg;

  389. 

  390.         midiProg.bank    = 0;

  391.         midiProg.program = index;

  392. 

  393.         switch (index)

  394.         {

  395.         case 0:

  396.             midiProg.name = "AlienWah1";

  397.             break;

  398.         case 1:

  399.             midiProg.name = "AlienWah2";

  400.             break;

  401.         case 2:

  402.             midiProg.name = "AlienWah3";

  403.             break;

  404.         case 3:

  405.             midiProg.name = "AlienWah4";

  406.             break;

  407.         default:

  408.             midiProg.name = nullptr;

  409.             break;

  410.         }

  411. 

  412.         return &midiProg;

  413.     }

  414. 

  415.     // -------------------------------------------------------------------

  416. 

  417.     PluginClassEND(FxAlienWahPlugin)

  418.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  419. };

  420. 

  421. // -----------------------------------------------------------------------

  422. 

  423. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  424. {

  425. public:

  426.     FxChorusPlugin(const NativeHostDescriptor* const host)

  427.         : FxAbstractPlugin(host, 12, 10) {}

  428. 

  429. protected:

  430.     // -------------------------------------------------------------------

  431.     // Plugin parameter calls

  432. 

  433.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  434.     {

  435.         if (index >= fParamCount)

  436.             return nullptr;

  437. 

  438.         static NativeParameter param;

  439.         static NativeParameterScalePoint scalePoints[2];

  440. 

  441.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  442. 

  443.         param.name = nullptr;

  444.         param.unit = nullptr;

  445.         param.ranges.def       = 1.0f;

  446.         param.ranges.min       = 0.0f;

  447.         param.ranges.max       = 127.0f;

  448.         param.ranges.step      = 1.0f;

  449.         param.ranges.stepSmall = 1.0f;

  450.         param.ranges.stepLarge = 20.0f;

  451.         param.scalePointCount  = 0;

  452.         param.scalePoints      = nullptr;

  453. 

  454.         switch (index)

  455.         {

  456.         case 0:

  457.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  458.             param.name = "LFO Frequency";

  459.             param.ranges.def = 50.0f;

  460.             break;

  461.         case 1:

  462.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  463.             param.name = "LFO Randomness";

  464.             param.ranges.def = 0.0f;

  465.             break;

  466.         case 2:

  467.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  468.             param.name = "LFO Type";

  469.             param.ranges.def = 0.0f;

  470.             param.ranges.max = 1.0f;

  471.             param.scalePointCount = 2;

  472.             param.scalePoints     = scalePoints;

  473.             scalePoints[0].label  = "Sine";

  474.             scalePoints[1].label  = "Triangle";

  475.             scalePoints[0].value  = 0.0f;

  476.             scalePoints[1].value  = 1.0f;

  477.             break;

  478.         case 3:

  479.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  480.             param.name = "LFO Stereo";

  481.             param.ranges.def = 90.0f;

  482.             break;

  483.         case 4:

  484.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  485.             param.name = "Depth";

  486.             param.ranges.def = 40.0f;

  487.             break;

  488.         case 5:

  489.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  490.             param.name = "Delay";

  491.             param.ranges.def = 85.0f;

  492.             break;

  493.         case 6:

  494.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  495.             param.name = "Feedback";

  496.             param.ranges.def = 64.0f;

  497.             break;

  498.         case 7:

  499.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  500.             param.name = "L/R Cross";

  501.             param.ranges.def = 119.0f;

  502.             break;

  503.         case 8:

  504.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  505.             param.name = "Flange Mode";

  506.             param.ranges.def = 0.0f;

  507.             param.ranges.max = 1.0f;

  508.             break;

  509.         case 9:

  510.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  511.             param.name = "Subtract Output";

  512.             param.ranges.def = 0.0f;

  513.             param.ranges.max = 1.0f;

  514.             break;

  515.         }

  516. 

  517.         param.hints = static_cast<NativeParameterHints>(hints);

  518. 

  519.         return &param;

  520.     }

  521. 

  522.     // -------------------------------------------------------------------

  523.     // Plugin midi-program calls

  524. 

  525.     const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const override

  526.     {

  527.         if (index >= fProgramCount)

  528.             return nullptr;

  529. 

  530.         static NativeMidiProgram midiProg;

  531. 

  532.         midiProg.bank    = 0;

  533.         midiProg.program = index;

  534. 

  535.         switch (index)

  536.         {

  537.         case 0:

  538.             midiProg.name = "Chorus1";

  539.             break;

  540.         case 1:

  541.             midiProg.name = "Chorus2";

  542.             break;

  543.         case 2:

  544.             midiProg.name = "Chorus3";

  545.             break;

  546.         case 3:

  547.             midiProg.name = "Celeste1";

  548.             break;

  549.         case 4:

  550.             midiProg.name = "Celeste2";

  551.             break;

  552.         case 5:

  553.             midiProg.name = "Flange1";

  554.             break;

  555.         case 6:

  556.             midiProg.name = "Flange2";

  557.             break;

  558.         case 7:

  559.             midiProg.name = "Flange3";

  560.             break;

  561.         case 8:

  562.             midiProg.name = "Flange4";

  563.             break;

  564.         case 9:

  565.             midiProg.name = "Flange5";

  566.             break;

  567.         default:

  568.             midiProg.name = nullptr;

  569.             break;

  570.         }

  571. 

  572.         return &midiProg;

  573.     }

  574. 

  575.     // -------------------------------------------------------------------

  576. 

  577.     PluginClassEND(FxChorusPlugin)

  578.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  579. };

  580. 

  581. // -----------------------------------------------------------------------

  582. 

  583. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  584. {

  585. public:

  586.     FxDistortionPlugin(const NativeHostDescriptor* const host)

  587.         : FxAbstractPlugin(host, 11, 6) {}

  588. 

  589. protected:

  590.     // -------------------------------------------------------------------

  591.     // Plugin parameter calls

  592. 

  593.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  594.     {

  595.         if (index >= fParamCount)

  596.             return nullptr;

  597. 

  598.         static NativeParameter param;

  599.         static NativeParameterScalePoint scalePoints[14];

  600. 

  601.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  602. 

  603.         param.name = nullptr;

  604.         param.unit = nullptr;

  605.         param.ranges.def       = 1.0f;

  606.         param.ranges.min       = 0.0f;

  607.         param.ranges.max       = 127.0f;

  608.         param.ranges.step      = 1.0f;

  609.         param.ranges.stepSmall = 1.0f;

  610.         param.ranges.stepLarge = 20.0f;

  611.         param.scalePointCount  = 0;

  612.         param.scalePoints      = nullptr;

  613. 

  614.         switch (index)

  615.         {

  616.         case 0:

  617.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  618.             param.name = "L/R Cross";

  619.             param.ranges.def = 35.0f;

  620.             break;

  621.         case 1:

  622.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  623.             param.name = "Drive";

  624.             param.ranges.def = 56.0f;

  625.             break;

  626.         case 2:

  627.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  628.             param.name = "Level";

  629.             param.ranges.def = 70.0f;

  630.             break;

  631.         case 3:

  632.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  633.             param.name = "Type";

  634.             param.ranges.def = 0.0f;

  635.             param.ranges.max = 13.0f;

  636.             param.scalePointCount = 14;

  637.             param.scalePoints     = scalePoints;

  638.             scalePoints[ 0].label = "Arctangent";

  639.             scalePoints[ 1].label = "Asymmetric";

  640.             scalePoints[ 2].label = "Pow";

  641.             scalePoints[ 3].label = "Sine";

  642.             scalePoints[ 4].label = "Quantisize";

  643.             scalePoints[ 5].label = "Zigzag";

  644.             scalePoints[ 6].label = "Limiter";

  645.             scalePoints[ 7].label = "Upper Limiter";

  646.             scalePoints[ 8].label = "Lower Limiter";

  647.             scalePoints[ 9].label = "Inverse Limiter";

  648.             scalePoints[10].label = "Clip";

  649.             scalePoints[11].label = "Asym2";

  650.             scalePoints[12].label = "Pow2";

  651.             scalePoints[13].label = "Sigmoid";

  652.             scalePoints[ 0].value = 0.0f;

  653.             scalePoints[ 1].value = 1.0f;

  654.             scalePoints[ 2].value = 2.0f;

  655.             scalePoints[ 3].value = 3.0f;

  656.             scalePoints[ 4].value = 4.0f;

  657.             scalePoints[ 5].value = 5.0f;

  658.             scalePoints[ 6].value = 6.0f;

  659.             scalePoints[ 7].value = 7.0f;

  660.             scalePoints[ 8].value = 8.0f;

  661.             scalePoints[ 9].value = 9.0f;

  662.             scalePoints[10].value = 10.0f;

  663.             scalePoints[11].value = 11.0f;

  664.             scalePoints[12].value = 12.0f;

  665.             scalePoints[13].value = 13.0f;

  666.             break;

  667.         case 4:

  668.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  669.             param.name = "Negate";

  670.             param.ranges.def = 0.0f;

  671.             param.ranges.max = 1.0f;

  672.             break;

  673.         case 5:

  674.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  675.             param.name = "Low-Pass Filter";

  676.             param.ranges.def = 96.0f;

  677.             break;

  678.         case 6:

  679.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  680.             param.name = "High-Pass Filter";

  681.             param.ranges.def = 0.0f;

  682.             break;

  683.         case 7:

  684.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  685.             param.name = "Stereo";

  686.             param.ranges.def = 0.0f;

  687.             param.ranges.max = 1.0f;

  688.             break;

  689.         case 8:

  690.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  691.             param.name = "Pre-Filtering";

  692.             param.ranges.def = 0.0f;

  693.             param.ranges.max = 1.0f;

  694.             break;

  695.         }

  696. 

  697.         param.hints = static_cast<NativeParameterHints>(hints);

  698. 

  699.         return &param;

  700.     }

  701. 

  702.     // -------------------------------------------------------------------

  703.     // Plugin midi-program calls

  704. 

  705.     const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const override

  706.     {

  707.         if (index >= fProgramCount)

  708.             return nullptr;

  709. 

  710.         static NativeMidiProgram midiProg;

  711. 

  712.         midiProg.bank    = 0;

  713.         midiProg.program = index;

  714. 

  715.         switch (index)

  716.         {

  717.         case 0:

  718.             midiProg.name = "Overdrive 1";

  719.             break;

  720.         case 1:

  721.             midiProg.name = "Overdrive 2";

  722.             break;

  723.         case 2:

  724.             midiProg.name = "A. Exciter 1";

  725.             break;

  726.         case 3:

  727.             midiProg.name = "A. Exciter 2";

  728.             break;

  729.         case 4:

  730.             midiProg.name = "Guitar Amp";

  731.             break;

  732.         case 5:

  733.             midiProg.name = "Quantisize";

  734.             break;

  735.         default:

  736.             midiProg.name = nullptr;

  737.             break;

  738.         }

  739. 

  740.         return &midiProg;

  741.     }

  742. 

  743.     // -------------------------------------------------------------------

  744. 

  745.     PluginClassEND(FxDistortionPlugin)

  746.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  747. };

  748. 

  749. // -----------------------------------------------------------------------

  750. 

  751. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  752. {

  753. public:

  754.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

  755.         : FxAbstractPlugin(host, 10, 5) {}

  756. 

  757. protected:

  758.     // -------------------------------------------------------------------

  759.     // Plugin parameter calls

  760. 

  761.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  762.     {

  763.         if (index >= fParamCount)

  764.             return nullptr;

  765. 

  766.         static NativeParameter param;

  767.         static NativeParameterScalePoint scalePoints[2];

  768. 

  769.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  770. 

  771.         param.name = nullptr;

  772.         param.unit = nullptr;

  773.         param.ranges.def       = 1.0f;

  774.         param.ranges.min       = 0.0f;

  775.         param.ranges.max       = 127.0f;

  776.         param.ranges.step      = 1.0f;

  777.         param.ranges.stepSmall = 1.0f;

  778.         param.ranges.stepLarge = 20.0f;

  779.         param.scalePointCount  = 0;

  780.         param.scalePoints      = nullptr;

  781. 

  782.         switch (index)

  783.         {

  784.         case 0:

  785.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  786.             param.name = "LFO Frequency";

  787.             param.ranges.def = 80.0f;

  788.             break;

  789.         case 1:

  790.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  791.             param.name = "LFO Randomness";

  792.             param.ranges.def = 0.0f;

  793.             break;

  794.         case 2:

  795.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  796.             param.name = "LFO Type";

  797.             param.ranges.def = 0.0f;

  798.             param.ranges.max = 1.0f;

  799.             param.scalePointCount = 2;

  800.             param.scalePoints     = scalePoints;

  801.             scalePoints[0].label  = "Sine";

  802.             scalePoints[1].label  = "Triangle";

  803.             scalePoints[0].value  = 0.0f;

  804.             scalePoints[1].value  = 1.0f;

  805.             break;

  806.         case 3:

  807.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  808.             param.name = "LFO Stereo";

  809.             param.ranges.def = 64.0f;

  810.             break;

  811.         case 4:

  812.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  813.             param.name = "LFO Depth";

  814.             param.ranges.def = 0.0f;

  815.             break;

  816.         case 5:

  817.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  818.             param.name = "Amp sns";

  819.             param.ranges.def = 90.0f;

  820.             break;

  821.         case 6:

  822.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  823.             param.name = "Amp sns inv";

  824.             param.ranges.def = 0.0f;

  825.             param.ranges.max = 1.0f;

  826.             break;

  827.         case 7:

  828.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  829.             param.name = "Amp Smooth";

  830.             param.ranges.def = 60.0f;

  831.             break;

  832.         }

  833. 

  834.         param.hints = static_cast<NativeParameterHints>(hints);

  835. 

  836.         return &param;

  837.     }

  838. 

  839.     // -------------------------------------------------------------------

  840.     // Plugin midi-program calls

  841. 

  842.     const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const override

  843.     {

  844.         if (index >= fProgramCount)

  845.             return nullptr;

  846. 

  847.         static NativeMidiProgram midiProg;

  848. 

  849.         midiProg.bank    = 0;

  850.         midiProg.program = index;

  851. 

  852.         switch (index)

  853.         {

  854.         case 0:

  855.             midiProg.name = "WahWah";

  856.             break;

  857.         case 1:

  858.             midiProg.name = "AutoWah";

  859.             break;

  860.         case 2:

  861.             midiProg.name = "Sweep";

  862.             break;

  863.         case 3:

  864.             midiProg.name = "VocalMorph1";

  865.             break;

  866.         case 4:

  867.             midiProg.name = "VocalMorph2";

  868.             break;

  869.         default:

  870.             midiProg.name = nullptr;

  871.             break;

  872.         }

  873. 

  874.         return &midiProg;

  875.     }

  876. 

  877.     // -------------------------------------------------------------------

  878. 

  879.     PluginClassEND(FxDynamicFilterPlugin)

  880.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  881. };

  882. 

  883. // -----------------------------------------------------------------------

  884. 

  885. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  886. {

  887. public:

  888.     FxEchoPlugin(const NativeHostDescriptor* const host)

  889.         : FxAbstractPlugin(host, 7, 9) {}

  890. 

  891. protected:

  892.     // -------------------------------------------------------------------

  893.     // Plugin parameter calls

  894. 

  895.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  896.     {

  897.         if (index >= fParamCount)

  898.             return nullptr;

  899. 

  900.         static NativeParameter param;

  901. 

  902.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  903. 

  904.         param.name = nullptr;

  905.         param.unit = nullptr;

  906.         param.ranges.def       = 1.0f;

  907.         param.ranges.min       = 0.0f;

  908.         param.ranges.max       = 127.0f;

  909.         param.ranges.step      = 1.0f;

  910.         param.ranges.stepSmall = 1.0f;

  911.         param.ranges.stepLarge = 20.0f;

  912.         param.scalePointCount  = 0;

  913.         param.scalePoints      = nullptr;

  914. 

  915.         switch (index)

  916.         {

  917.         case 0:

  918.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  919.             param.name = "Delay";

  920.             param.ranges.def = 35.0f;

  921.             break;

  922.         case 1:

  923.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  924.             param.name = "L/R Delay";

  925.             param.ranges.def = 64.0f;

  926.             break;

  927.         case 2:

  928.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  929.             param.name = "L/R Cross";

  930.             param.ranges.def = 30.0f;

  931.             break;

  932.         case 3:

  933.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  934.             param.name = "Feedback";

  935.             param.ranges.def = 59.0f;

  936.             break;

  937.         case 4:

  938.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  939.             param.name = "High Damp";

  940.             param.ranges.def = 0.0f;

  941.             break;

  942.         }

  943. 

  944.         param.hints = static_cast<NativeParameterHints>(hints);

  945. 

  946.         return &param;

  947.     }

  948. 

  949.     // -------------------------------------------------------------------

  950.     // Plugin midi-program calls

  951. 

  952.     const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const override

  953.     {

  954.         if (index >= fProgramCount)

  955.             return nullptr;

  956. 

  957.         static NativeMidiProgram midiProg;

  958. 

  959.         midiProg.bank    = 0;

  960.         midiProg.program = index;

  961. 

  962.         switch (index)

  963.         {

  964.         case 0:

  965.             midiProg.name = "Echo 1";

  966.             break;

  967.         case 1:

  968.             midiProg.name = "Echo 2";

  969.             break;

  970.         case 2:

  971.             midiProg.name = "Echo 3";

  972.             break;

  973.         case 3:

  974.             midiProg.name = "Simple Echo";

  975.             break;

  976.         case 4:

  977.             midiProg.name = "Canyon";

  978.             break;

  979.         case 5:

  980.             midiProg.name = "Panning Echo 1";

  981.             break;

  982.         case 6:

  983.             midiProg.name = "Panning Echo 2";

  984.             break;

  985.         case 7:

  986.             midiProg.name = "Panning Echo 3";

  987.             break;

  988.         case 8:

  989.             midiProg.name = "Feedback Echo";

  990.             break;

  991.         default:

  992.             midiProg.name = nullptr;

  993.             break;

  994.         }

  995. 

  996.         return &midiProg;

  997.     }

  998. 

  999.     // -------------------------------------------------------------------

  1000. 

  1001.     PluginClassEND(FxEchoPlugin)

  1002.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  1003. };

  1004. 

  1005. // -----------------------------------------------------------------------

  1006. 

  1007. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  1008. {

  1009. public:

  1010.     FxPhaserPlugin(const NativeHostDescriptor* const host)

  1011.         : FxAbstractPlugin(host, 15, 12) {}

  1012. 

  1013. protected:

  1014.     // -------------------------------------------------------------------

  1015.     // Plugin parameter calls

  1016. 

  1017.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  1018.     {

  1019.         if (index >= fParamCount)

  1020.             return nullptr;

  1021. 

  1022.         static NativeParameter param;

  1023.         static NativeParameterScalePoint scalePoints[2];

  1024. 

  1025.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1026. 

  1027.         param.name = nullptr;

  1028.         param.unit = nullptr;

  1029.         param.ranges.def       = 1.0f;

  1030.         param.ranges.min       = 0.0f;

  1031.         param.ranges.max       = 127.0f;

  1032.         param.ranges.step      = 1.0f;

  1033.         param.ranges.stepSmall = 1.0f;

  1034.         param.ranges.stepLarge = 20.0f;

  1035.         param.scalePointCount  = 0;

  1036.         param.scalePoints      = nullptr;

  1037. 

  1038.         switch (index)

  1039.         {

  1040.         case 0:

  1041.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1042.             param.name = "LFO Frequency";

  1043.             param.ranges.def = 36.0f;

  1044.             break;

  1045.         case 1:

  1046.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1047.             param.name = "LFO Randomness";

  1048.             param.ranges.def = 0.0f;

  1049.             break;

  1050.         case 2:

  1051.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1052.             param.name = "LFO Type";

  1053.             param.ranges.def = 0.0f;

  1054.             param.ranges.max = 1.0f;

  1055.             param.scalePointCount = 2;

  1056.             param.scalePoints     = scalePoints;

  1057.             scalePoints[0].label  = "Sine";

  1058.             scalePoints[1].label  = "Triangle";

  1059.             scalePoints[0].value  = 0.0f;

  1060.             scalePoints[1].value  = 1.0f;

  1061.             break;

  1062.         case 3:

  1063.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1064.             param.name = "LFO Stereo";

  1065.             param.ranges.def = 64.0f;

  1066.             break;

  1067.         case 4:

  1068.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1069.             param.name = "Depth";

  1070.             param.ranges.def = 110.0f;

  1071.             break;

  1072.         case 5:

  1073.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1074.             param.name = "Feedback";

  1075.             param.ranges.def = 64.0f;

  1076.             break;

  1077.         case 6:

  1078.             param.name = "Stages";

  1079.             param.ranges.def = 1.0f;

  1080.             param.ranges.min = 1.0f;

  1081.             param.ranges.max = 12.0f;

  1082.             break;

  1083.         case 7:

  1084.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1085.             param.name = "L/R Cross|Offset";

  1086.             param.ranges.def = 0.0f;

  1087.             break;

  1088.         case 8:

  1089.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1090.             param.name = "Subtract Output";

  1091.             param.ranges.def = 0.0f;

  1092.             param.ranges.max = 1.0f;

  1093.             break;

  1094.         case 9:

  1095.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1096.             param.name = "Phase|Width";

  1097.             param.ranges.def = 20.0f;

  1098.             break;

  1099.         case 10:

  1100.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1101.             param.name = "Hyper";

  1102.             param.ranges.def = 0.0f;

  1103.             param.ranges.max = 1.0f;

  1104.             break;

  1105.         case 11:

  1106.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1107.             param.name = "Distortion";

  1108.             param.ranges.def = 0.0f;

  1109.             break;

  1110.         case 12:

  1111.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1112.             param.name = "Analog";

  1113.             param.ranges.def = 0.0f;

  1114.             param.ranges.max = 1.0f;

  1115.             break;

  1116.         }

  1117. 

  1118.         param.hints = static_cast<NativeParameterHints>(hints);

  1119. 

  1120.         return &param;

  1121.     }

  1122. 

  1123.     // -------------------------------------------------------------------

  1124.     // Plugin midi-program calls

  1125. 

  1126.     const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const override

  1127.     {

  1128.         if (index >= fProgramCount)

  1129.             return nullptr;

  1130. 

  1131.         static NativeMidiProgram midiProg;

  1132. 

  1133.         midiProg.bank    = 0;

  1134.         midiProg.program = index;

  1135. 

  1136.         switch (index)

  1137.         {

  1138.         case 0:

  1139.             midiProg.name = "Phaser 1";

  1140.             break;

  1141.         case 1:

  1142.             midiProg.name = "Phaser 2";

  1143.             break;

  1144.         case 2:

  1145.             midiProg.name = "Phaser 3";

  1146.             break;

  1147.         case 3:

  1148.             midiProg.name = "Phaser 4";

  1149.             break;

  1150.         case 4:

  1151.             midiProg.name = "Phaser 5";

  1152.             break;

  1153.         case 5:

  1154.             midiProg.name = "Phaser 6";

  1155.             break;

  1156.         case 6:

  1157.             midiProg.name = "APhaser 1";

  1158.             break;

  1159.         case 7:

  1160.             midiProg.name = "APhaser 2";

  1161.             break;

  1162.         case 8:

  1163.             midiProg.name = "APhaser 3";

  1164.             break;

  1165.         case 9:

  1166.             midiProg.name = "APhaser 4";

  1167.             break;

  1168.         case 10:

  1169.             midiProg.name = "APhaser 5";

  1170.             break;

  1171.         case 11:

  1172.             midiProg.name = "APhaser 6";

  1173.             break;

  1174.         default:

  1175.             midiProg.name = nullptr;

  1176.             break;

  1177.         }

  1178. 

  1179.         return &midiProg;

  1180.     }

  1181. 

  1182.     // -------------------------------------------------------------------

  1183. 

  1184.     PluginClassEND(FxPhaserPlugin)

  1185.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1186. };

  1187. 

  1188. // -----------------------------------------------------------------------

  1189. 

  1190. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1191. {

  1192. public:

  1193.     FxReverbPlugin(const NativeHostDescriptor* const host)

  1194.         : FxAbstractPlugin(host, 13, 13) {}

  1195. 

  1196. protected:

  1197.     // -------------------------------------------------------------------

  1198.     // Plugin parameter calls

  1199. 

  1200.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  1201.     {

  1202.         if (index >= fParamCount)

  1203.             return nullptr;

  1204. 

  1205.         static NativeParameter param;

  1206.         static NativeParameterScalePoint scalePoints[3];

  1207. 

  1208.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1209. 

  1210.         param.name = nullptr;

  1211.         param.unit = nullptr;

  1212.         param.ranges.def       = 1.0f;

  1213.         param.ranges.min       = 0.0f;

  1214.         param.ranges.max       = 127.0f;

  1215.         param.ranges.step      = 1.0f;

  1216.         param.ranges.stepSmall = 1.0f;

  1217.         param.ranges.stepLarge = 20.0f;

  1218.         param.scalePointCount  = 0;

  1219.         param.scalePoints      = nullptr;

  1220. 

  1221.         switch (index)

  1222.         {

  1223.         case 0:

  1224.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1225.             param.name = "Time";

  1226.             param.ranges.def = 63.0f;

  1227.             break;

  1228.         case 1:

  1229.             param.name = "Delay";

  1230.             param.ranges.def = 24.0f;

  1231.             break;

  1232.         case 2:

  1233.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1234.             param.name = "Feedback";

  1235.             param.ranges.def = 0.0f;

  1236.             break;

  1237.         case 3:

  1238.             hints = 0x0;

  1239.             param.name = "bw";

  1240.             break;

  1241.         case 4:

  1242.             hints = 0x0;

  1243.             param.name = "E/R";

  1244.             break;

  1245.         case 5:

  1246.             param.name = "Low-Pass Filter";

  1247.             param.ranges.def = 85.0f;

  1248.             break;

  1249.         case 6:

  1250.             param.name = "High-Pass Filter";

  1251.             param.ranges.def = 5.0f;

  1252.             break;

  1253.         case 7:

  1254.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1255.             param.name = "Damp";

  1256.             param.ranges.def = 83.0f;

  1257.             param.ranges.min = 64.0f;

  1258.             break;

  1259.         case 8:

  1260.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1261.             param.name = "Type";

  1262.             param.ranges.def = 1.0f;

  1263.             param.ranges.max = 2.0f;

  1264.             param.scalePointCount = 3;

  1265.             param.scalePoints     = scalePoints;

  1266.             scalePoints[0].label  = "Random";

  1267.             scalePoints[1].label  = "Freeverb";

  1268.             scalePoints[2].label  = "Bandwidth";

  1269.             scalePoints[0].value  = 0.0f;

  1270.             scalePoints[1].value  = 1.0f;

  1271.             scalePoints[2].value  = 2.0f;

  1272.             break;

  1273.         case 9:

  1274.             param.name = "Room size";

  1275.             param.ranges.def = 64.0f;

  1276.             param.ranges.min = 1.0f;

  1277.             break;

  1278.         case 10:

  1279.             param.name = "Bandwidth";

  1280.             param.ranges.def = 20.0f;

  1281.             break;

  1282.         }

  1283. 

  1284.         param.hints = static_cast<NativeParameterHints>(hints);

  1285. 

  1286.         return &param;

  1287.     }

  1288. 

  1289.     // -------------------------------------------------------------------

  1290.     // Plugin midi-program calls

  1291. 

  1292.     const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const override

  1293.     {

  1294.         if (index >= fProgramCount)

  1295.             return nullptr;

  1296. 

  1297.         static NativeMidiProgram midiProg;

  1298. 

  1299.         midiProg.bank    = 0;

  1300.         midiProg.program = index;

  1301. 

  1302.         switch (index)

  1303.         {

  1304.         case 0:

  1305.             midiProg.name = "Cathedral1";

  1306.             break;

  1307.         case 1:

  1308.             midiProg.name = "Cathedral2";

  1309.             break;

  1310.         case 2:

  1311.             midiProg.name = "Cathedral3";

  1312.             break;

  1313.         case 3:

  1314.             midiProg.name = "Hall1";

  1315.             break;

  1316.         case 4:

  1317.             midiProg.name = "Hall2";

  1318.             break;

  1319.         case 5:

  1320.             midiProg.name = "Room1";

  1321.             break;

  1322.         case 6:

  1323.             midiProg.name = "Room2";

  1324.             break;

  1325.         case 7:

  1326.             midiProg.name = "Basement";

  1327.             break;

  1328.         case 8:

  1329.             midiProg.name = "Tunnel";

  1330.             break;

  1331.         case 9:

  1332.             midiProg.name = "Echoed1";

  1333.             break;

  1334.         case 10:

  1335.             midiProg.name = "Echoed2";

  1336.             break;

  1337.         case 11:

  1338.             midiProg.name = "VeryLong1";

  1339.             break;

  1340.         case 12:

  1341.             midiProg.name = "VeryLong2";

  1342.             break;

  1343.         default:

  1344.             midiProg.name = nullptr;

  1345.             break;

  1346.         }

  1347. 

  1348.         return &midiProg;

  1349.     }

  1350. 

  1351.     // -------------------------------------------------------------------

  1352. 

  1353.     PluginClassEND(FxReverbPlugin)

  1354.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1355. };

  1356. 

  1357. // -----------------------------------------------------------------------

  1358. 

  1359. static const NativePluginDescriptor fxAlienWahDesc = {

  1360.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

  1361.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_RTSAFE

  1362.                                                   |NATIVE_PLUGIN_USES_PANNING

  1363.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1364.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1365.     /* audioIns  */ 2,

  1366.     /* audioOuts */ 2,

  1367.     /* midiIns   */ 0,

  1368.     /* midiOuts  */ 0,

  1369.     /* paramIns  */ 11-2,

  1370.     /* paramOuts */ 0,

  1371.     /* name      */ "ZynAlienWah",

  1372.     /* label     */ "zynalienwah",

  1373.     /* maker     */ "falkTX, Mark McCurry, Nasca Octavian Paul",

  1374.     /* copyright */ "GNU GPL v2+",

  1375.     PluginDescriptorFILL(FxAlienWahPlugin)

  1376. };

  1377. 

  1378. static const NativePluginDescriptor fxChorusDesc = {

  1379.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

  1380.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_RTSAFE

  1381.                                                   |NATIVE_PLUGIN_USES_PANNING

  1382.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1383.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1384.     /* audioIns  */ 2,

  1385.     /* audioOuts */ 2,

  1386.     /* midiIns   */ 0,

  1387.     /* midiOuts  */ 0,

  1388.     /* paramIns  */ 12-2,

  1389.     /* paramOuts */ 0,

  1390.     /* name      */ "ZynChorus",

  1391.     /* label     */ "zynchorus",

  1392.     /* maker     */ "falkTX, Mark McCurry, Nasca Octavian Paul",

  1393.     /* copyright */ "GNU GPL v2+",

  1394.     PluginDescriptorFILL(FxChorusPlugin)

  1395. };

  1396. 

  1397. static const NativePluginDescriptor fxDistortionDesc = {

  1398.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

  1399.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_USES_PANNING

  1400.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1401.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1402.     /* audioIns  */ 2,

  1403.     /* audioOuts */ 2,

  1404.     /* midiIns   */ 0,

  1405.     /* midiOuts  */ 0,

  1406.     /* paramIns  */ 11-2,

  1407.     /* paramOuts */ 0,

  1408.     /* name      */ "ZynDistortion",

  1409.     /* label     */ "zyndistortion",

  1410.     /* maker     */ "falkTX, Mark McCurry, Nasca Octavian Paul",

  1411.     /* copyright */ "GNU GPL v2+",

  1412.     PluginDescriptorFILL(FxDistortionPlugin)

  1413. };

  1414. 

  1415. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1416.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

  1417.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_USES_PANNING

  1418.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1419.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1420.     /* audioIns  */ 2,

  1421.     /* audioOuts */ 2,

  1422.     /* midiIns   */ 0,

  1423.     /* midiOuts  */ 0,

  1424.     /* paramIns  */ 10-2,

  1425.     /* paramOuts */ 0,

  1426.     /* name      */ "ZynDynamicFilter",

  1427.     /* label     */ "zyndynamicfilter",

  1428.     /* maker     */ "falkTX, Mark McCurry, Nasca Octavian Paul",

  1429.     /* copyright */ "GNU GPL v2+",

  1430.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1431. };

  1432. 

  1433. static const NativePluginDescriptor fxEchoDesc = {

  1434.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

  1435.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_RTSAFE

  1436.                                                   |NATIVE_PLUGIN_USES_PANNING

  1437.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1438.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1439.     /* audioIns  */ 2,

  1440.     /* audioOuts */ 2,

  1441.     /* midiIns   */ 0,

  1442.     /* midiOuts  */ 0,

  1443.     /* paramIns  */ 7-2,

  1444.     /* paramOuts */ 0,

  1445.     /* name      */ "ZynEcho",

  1446.     /* label     */ "zynecho",

  1447.     /* maker     */ "falkTX, Mark McCurry, Nasca Octavian Paul",

  1448.     /* copyright */ "GNU GPL v2+",

  1449.     PluginDescriptorFILL(FxEchoPlugin)

  1450. };

  1451. 

  1452. static const NativePluginDescriptor fxPhaserDesc = {

  1453.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

  1454.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_USES_PANNING

  1455.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1456.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1457.     /* audioIns  */ 2,

  1458.     /* audioOuts */ 2,

  1459.     /* midiIns   */ 0,

  1460.     /* midiOuts  */ 0,

  1461.     /* paramIns  */ 15-2,

  1462.     /* paramOuts */ 0,

  1463.     /* name      */ "ZynPhaser",

  1464.     /* label     */ "zynphaser",

  1465.     /* maker     */ "falkTX, Mark McCurry, Nasca Octavian Paul",

  1466.     /* copyright */ "GNU GPL v2+",

  1467.     PluginDescriptorFILL(FxPhaserPlugin)

  1468. };

  1469. 

  1470. static const NativePluginDescriptor fxReverbDesc = {

  1471.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

  1472.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_USES_PANNING

  1473.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1474.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1475.     /* audioIns  */ 2,

  1476.     /* audioOuts */ 2,

  1477.     /* midiIns   */ 0,

  1478.     /* midiOuts  */ 0,

  1479.     /* paramIns  */ 13-2,

  1480.     /* paramOuts */ 0,

  1481.     /* name      */ "ZynReverb",

  1482.     /* label     */ "zynreverb",

  1483.     /* maker     */ "falkTX, Mark McCurry, Nasca Octavian Paul",

  1484.     /* copyright */ "GNU GPL v2+",

  1485.     PluginDescriptorFILL(FxReverbPlugin)

  1486. };

  1487. 

  1488. // -----------------------------------------------------------------------

  1489. 

  1490. CARLA_API_EXPORT

  1491. void carla_register_native_plugin_zynaddsubfx_fx();

  1492. 

  1493. CARLA_API_EXPORT

  1494. void carla_register_native_plugin_zynaddsubfx_fx()

  1495. {

  1496.     carla_register_native_plugin(&fxAlienWahDesc);

  1497.     carla_register_native_plugin(&fxChorusDesc);

  1498.     carla_register_native_plugin(&fxDistortionDesc);

  1499.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1500.     carla_register_native_plugin(&fxEchoDesc);

  1501.     carla_register_native_plugin(&fxPhaserDesc);

  1502.     carla_register_native_plugin(&fxReverbDesc);

  1503. }

  1504. 

  1505. // -----------------------------------------------------------------------