falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3412 Commits
17 Branches
381MB
Tree: 64fb39b13a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '64fb39b13a'
${ noResults }
Carla/source/native-plugins/zynaddsubfx-fx.cpp

1490 lines
44KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2015 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaNative.hpp"

  19. #include "CarlaMathUtils.hpp"

  20. 

  21. #include "Effects/Alienwah.h"

  22. #include "Effects/Chorus.h"

  23. #include "Effects/Distorsion.h"

  24. #include "Effects/DynamicFilter.h"

  25. #include "Effects/Echo.h"

  26. #include "Effects/Phaser.h"

  27. #include "Effects/Reverb.h"

  28. #include "Misc/Allocator.h"

  29. 

  30. #include "juce_audio_basics/juce_audio_basics.h"

  31. 

  32. using juce::roundToIntAccurate;

  33. using juce::FloatVectorOperations;

  34. using juce::SharedResourcePointer;

  35. 

  36. // -----------------------------------------------------------------------

  37. 

  38. template<class ZynFX>

  39. class FxAbstractPlugin : public NativePluginClass

  40. {

  41. protected:

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

  43.         : NativePluginClass(host),

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

  45.           fProgramCount(programCount),

  46.           fParamValues(new uchar[paramCount]),

  47.           fParamsChanged(new bool[paramCount]),

  48.           fNextProgram(-1),

  49.           fBufferSize(getBufferSize()),

  50.           fSampleRate(getSampleRate()),

  51.           fFilterParams(nullptr),

  52.           fEffect(nullptr),

  53.           efxoutl(nullptr),

  54.           efxoutr(nullptr)

  55.     {

  56.         const int ibufferSize(static_cast<int>(fBufferSize));

  57. 

  58.         efxoutl = new float[fBufferSize];

  59.         efxoutr = new float[fBufferSize];

  60.         FloatVectorOperations::clear(efxoutl, ibufferSize);

  61.         FloatVectorOperations::clear(efxoutr, ibufferSize);

  62. 

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

  64. 

  65.         doReinit(true);

  66.     }

  67. 

  68.     ~FxAbstractPlugin() override

  69.     {

  70.         if (efxoutl != nullptr)

  71.         {

  72.             delete[] efxoutl;

  73.             efxoutl = nullptr;

  74.         }

  75. 

  76.         if (efxoutr != nullptr)

  77.         {

  78.             delete[] efxoutr;

  79.             efxoutr = nullptr;

  80.         }

  81. 

  82.         if (fEffect != nullptr)

  83.         {

  84.             delete fEffect;

  85.             fEffect = nullptr;

  86.         }

  87.     }

  88. 

  89.     // -------------------------------------------------------------------

  90.     // Plugin parameter calls

  91. 

  92.     uint32_t getParameterCount() const final

  93.     {

  94.         return fParamCount;

  95.     }

  96. 

  97.     float getParameterValue(const uint32_t index) const final

  98.     {

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

  100.     }

  101. 

  102.     // -------------------------------------------------------------------

  103.     // Plugin midi-program calls

  104. 

  105.     uint32_t getMidiProgramCount() const final

  106.     {

  107.         return fProgramCount;

  108.     }

  109. 

  110.     // -------------------------------------------------------------------

  111.     // Plugin state calls

  112. 

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

  114.     {

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

  116. 

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

  118.         fParamsChanged[index] = true;

  119.     }

  120. 

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

  122.     {

  123.         fNextProgram = program;

  124.     }

  125. 

  126.     // -------------------------------------------------------------------

  127.     // Plugin process calls

  128. 

  129.     void activate() final

  130.     {

  131.         fEffect->cleanup();

  132.     }

  133. 

  134.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const NativeMidiEvent* const, const uint32_t) final

  135.     {

  136.         const int iframes(static_cast<int>(frames));

  137. 

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

  139.             FloatVectorOperations::copyWithMultiply(outBuffer[0], inBuffer[0], 0.5f, iframes);

  140.         else

  141.             FloatVectorOperations::multiply(outBuffer[0], 0.5f, iframes);

  142. 

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

  144.             FloatVectorOperations::copyWithMultiply(outBuffer[1], inBuffer[1], 0.5f, iframes);

  145.         else

  146.             FloatVectorOperations::multiply(outBuffer[1], 0.5f, iframes);

  147. 

  148.         const int32_t nextProgram = fNextProgram;

  149.         fNextProgram = -1;

  150. 

  151.         if (nextProgram >= 0)

  152.         {

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

  154. 

  155.             // reset volume and pan

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

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

  158. 

  159.             // ignore next

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

  161.         }

  162.         else

  163.         {

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

  165.             {

  166.                 if (! fParamsChanged[i])

  167.                     continue;

  168. 

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

  170.                 fParamsChanged[i] = false;

  171.             }

  172.         }

  173. 

  174.         fEffect->out(Stereo<float*>(inBuffer[0], inBuffer[1]));

  175. 

  176.         FloatVectorOperations::addWithMultiply(outBuffer[0], efxoutl, 0.5f, iframes);

  177.         FloatVectorOperations::addWithMultiply(outBuffer[1], efxoutr, 0.5f, iframes);

  178.     }

  179. 

  180.     // -------------------------------------------------------------------

  181.     // Plugin dispatcher

  182. 

  183.     void bufferSizeChanged(const uint32_t bufferSize) final

  184.     {

  185.         if (fBufferSize == bufferSize)

  186.             return;

  187. 

  188.         fBufferSize = bufferSize;

  189.         const int ibufferSize(static_cast<int>(fBufferSize));

  190. 

  191.         delete[] efxoutl;

  192.         delete[] efxoutr;

  193.         efxoutl = new float[bufferSize];

  194.         efxoutr = new float[bufferSize];

  195.         FloatVectorOperations::clear(efxoutl, ibufferSize);

  196.         FloatVectorOperations::clear(efxoutr, ibufferSize);

  197. 

  198.         doReinit(false);

  199.     }

  200. 

  201.     void sampleRateChanged(const double sampleRate) final

  202.     {

  203.         if (fSampleRate == sampleRate)

  204.             return;

  205. 

  206.         fSampleRate = sampleRate;

  207. 

  208.         doReinit(false);

  209.     }

  210. 

  211.     void doReinit(const bool firstInit)

  212.     {

  213.         uchar params[fParamCount];

  214. 

  215.         if (fEffect != nullptr)

  216.         {

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

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

  219. 

  220.             delete fEffect;

  221.         }

  222. 

  223.         EffectParams pars(fAllocator.getObject(), false, efxoutl, efxoutr, 0,

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

  225. 

  226.         fEffect = new ZynFX(pars);

  227. 

  228.         if (firstInit)

  229.         {

  230.             fEffect->setpreset(0);

  231. 

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

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

  234.         }

  235.         else

  236.         {

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

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

  239.         }

  240. 

  241.         // reset volume and pan

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

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

  244.     }

  245. 

  246.     // -------------------------------------------------------------------

  247. 

  248.     const uint32_t fParamCount;

  249.     const uint32_t fProgramCount;

  250. 

  251.     uchar* const fParamValues;

  252.     bool*  const fParamsChanged;

  253.     int32_t      fNextProgram;

  254. 

  255.     uint32_t fBufferSize;

  256.     double   fSampleRate;

  257. 

  258.     FilterParams fFilterParams;

  259.     Effect* fEffect;

  260.     float*  efxoutl;

  261.     float*  efxoutr;

  262. 

  263.     // FIXME - is this thread-safe?

  264.     SharedResourcePointer<AllocatorClass> fAllocator;

  265. 

  266.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  267. };

  268. 

  269. // -----------------------------------------------------------------------

  270. 

  271. class FxAlienWahPlugin : public FxAbstractPlugin<Alienwah>

  272. {

  273. public:

  274.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

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

  276. 

  277. protected:

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

  279.     // Plugin parameter calls

  280. 

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

  282.     {

  283.         if (index >= fParamCount)

  284.             return nullptr;

  285. 

  286.         static NativeParameter param;

  287.         static NativeParameterScalePoint scalePoints[2];

  288. 

  289.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  290. 

  291.         param.name = nullptr;

  292.         param.unit = nullptr;

  293.         param.ranges.def       = 1.0f;

  294.         param.ranges.min       = 0.0f;

  295.         param.ranges.max       = 127.0f;

  296.         param.ranges.step      = 1.0f;

  297.         param.ranges.stepSmall = 1.0f;

  298.         param.ranges.stepLarge = 20.0f;

  299.         param.scalePointCount  = 0;

  300.         param.scalePoints      = nullptr;

  301. 

  302.         switch (index)

  303.         {

  304.         case 0:

  305.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  306.             param.name = "LFO Frequency";

  307.             param.ranges.def = 70.0f;

  308.             break;

  309.         case 1:

  310.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  311.             param.name = "LFO Randomness";

  312.             param.ranges.def = 0.0f;

  313.             break;

  314.         case 2:

  315.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  316.             param.name = "LFO Type";

  317.             param.ranges.def = 0.0f;

  318.             param.ranges.max = 1.0f;

  319.             param.scalePointCount = 2;

  320.             param.scalePoints     = scalePoints;

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

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

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

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

  325.             break;

  326.         case 3:

  327.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  328.             param.name = "LFO Stereo";

  329.             param.ranges.def = 62.0f;

  330.             break;

  331.         case 4:

  332.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  333.             param.name = "Depth";

  334.             param.ranges.def = 60.0f;

  335.             break;

  336.         case 5:

  337.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  338.             param.name = "Feedback";

  339.             param.ranges.def = 105.0f;

  340.             break;

  341.         case 6:

  342.             param.name = "Delay";

  343.             param.ranges.def = 25.0f;

  344.             param.ranges.min = 1.0f;

  345.             param.ranges.max = 100.0f;

  346.             break;

  347.         case 7:

  348.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  350.             param.ranges.def = 0.0f;

  351.             break;

  352.         case 8:

  353.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  354.             param.name = "Phase";

  355.             param.ranges.def = 64.0f;

  356.             break;

  357.         }

  358. 

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

  360. 

  361.         return &param;

  362.     }

  363. 

  364.     // -------------------------------------------------------------------

  365.     // Plugin midi-program calls

  366. 

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

  368.     {

  369.         if (index >= fProgramCount)

  370.             return nullptr;

  371. 

  372.         static NativeMidiProgram midiProg;

  373. 

  374.         midiProg.bank    = 0;

  375.         midiProg.program = index;

  376. 

  377.         switch (index)

  378.         {

  379.         case 0:

  380.             midiProg.name = "AlienWah1";

  381.             break;

  382.         case 1:

  383.             midiProg.name = "AlienWah2";

  384.             break;

  385.         case 2:

  386.             midiProg.name = "AlienWah3";

  387.             break;

  388.         case 3:

  389.             midiProg.name = "AlienWah4";

  390.             break;

  391.         default:

  392.             midiProg.name = nullptr;

  393.             break;

  394.         }

  395. 

  396.         return &midiProg;

  397.     }

  398. 

  399.     // -------------------------------------------------------------------

  400. 

  401.     PluginClassEND(FxAlienWahPlugin)

  402.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  403. };

  404. 

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

  406. 

  407. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  408. {

  409. public:

  410.     FxChorusPlugin(const NativeHostDescriptor* const host)

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

  412. 

  413. protected:

  414.     // -------------------------------------------------------------------

  415.     // Plugin parameter calls

  416. 

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

  418.     {

  419.         if (index >= fParamCount)

  420.             return nullptr;

  421. 

  422.         static NativeParameter param;

  423.         static NativeParameterScalePoint scalePoints[2];

  424. 

  425.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  426. 

  427.         param.name = nullptr;

  428.         param.unit = nullptr;

  429.         param.ranges.def       = 1.0f;

  430.         param.ranges.min       = 0.0f;

  431.         param.ranges.max       = 127.0f;

  432.         param.ranges.step      = 1.0f;

  433.         param.ranges.stepSmall = 1.0f;

  434.         param.ranges.stepLarge = 20.0f;

  435.         param.scalePointCount  = 0;

  436.         param.scalePoints      = nullptr;

  437. 

  438.         switch (index)

  439.         {

  440.         case 0:

  441.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  442.             param.name = "LFO Frequency";

  443.             param.ranges.def = 50.0f;

  444.             break;

  445.         case 1:

  446.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  447.             param.name = "LFO Randomness";

  448.             param.ranges.def = 0.0f;

  449.             break;

  450.         case 2:

  451.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  452.             param.name = "LFO Type";

  453.             param.ranges.def = 0.0f;

  454.             param.ranges.max = 1.0f;

  455.             param.scalePointCount = 2;

  456.             param.scalePoints     = scalePoints;

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

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

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

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

  461.             break;

  462.         case 3:

  463.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  464.             param.name = "LFO Stereo";

  465.             param.ranges.def = 90.0f;

  466.             break;

  467.         case 4:

  468.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  469.             param.name = "Depth";

  470.             param.ranges.def = 40.0f;

  471.             break;

  472.         case 5:

  473.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  474.             param.name = "Delay";

  475.             param.ranges.def = 85.0f;

  476.             break;

  477.         case 6:

  478.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  479.             param.name = "Feedback";

  480.             param.ranges.def = 64.0f;

  481.             break;

  482.         case 7:

  483.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  485.             param.ranges.def = 119.0f;

  486.             break;

  487.         case 8:

  488.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  489.             param.name = "Flange Mode";

  490.             param.ranges.def = 0.0f;

  491.             param.ranges.max = 1.0f;

  492.             break;

  493.         case 9:

  494.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  495.             param.name = "Subtract Output";

  496.             param.ranges.def = 0.0f;

  497.             param.ranges.max = 1.0f;

  498.             break;

  499.         }

  500. 

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

  502. 

  503.         return &param;

  504.     }

  505. 

  506.     // -------------------------------------------------------------------

  507.     // Plugin midi-program calls

  508. 

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

  510.     {

  511.         if (index >= fProgramCount)

  512.             return nullptr;

  513. 

  514.         static NativeMidiProgram midiProg;

  515. 

  516.         midiProg.bank    = 0;

  517.         midiProg.program = index;

  518. 

  519.         switch (index)

  520.         {

  521.         case 0:

  522.             midiProg.name = "Chorus1";

  523.             break;

  524.         case 1:

  525.             midiProg.name = "Chorus2";

  526.             break;

  527.         case 2:

  528.             midiProg.name = "Chorus3";

  529.             break;

  530.         case 3:

  531.             midiProg.name = "Celeste1";

  532.             break;

  533.         case 4:

  534.             midiProg.name = "Celeste2";

  535.             break;

  536.         case 5:

  537.             midiProg.name = "Flange1";

  538.             break;

  539.         case 6:

  540.             midiProg.name = "Flange2";

  541.             break;

  542.         case 7:

  543.             midiProg.name = "Flange3";

  544.             break;

  545.         case 8:

  546.             midiProg.name = "Flange4";

  547.             break;

  548.         case 9:

  549.             midiProg.name = "Flange5";

  550.             break;

  551.         default:

  552.             midiProg.name = nullptr;

  553.             break;

  554.         }

  555. 

  556.         return &midiProg;

  557.     }

  558. 

  559.     // -------------------------------------------------------------------

  560. 

  561.     PluginClassEND(FxChorusPlugin)

  562.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  563. };

  564. 

  565. // -----------------------------------------------------------------------

  566. 

  567. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  568. {

  569. public:

  570.     FxDistortionPlugin(const NativeHostDescriptor* const host)

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

  572. 

  573. protected:

  574.     // -------------------------------------------------------------------

  575.     // Plugin parameter calls

  576. 

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

  578.     {

  579.         if (index >= fParamCount)

  580.             return nullptr;

  581. 

  582.         static NativeParameter param;

  583.         static NativeParameterScalePoint scalePoints[14];

  584. 

  585.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  586. 

  587.         param.name = nullptr;

  588.         param.unit = nullptr;

  589.         param.ranges.def       = 1.0f;

  590.         param.ranges.min       = 0.0f;

  591.         param.ranges.max       = 127.0f;

  592.         param.ranges.step      = 1.0f;

  593.         param.ranges.stepSmall = 1.0f;

  594.         param.ranges.stepLarge = 20.0f;

  595.         param.scalePointCount  = 0;

  596.         param.scalePoints      = nullptr;

  597. 

  598.         switch (index)

  599.         {

  600.         case 0:

  601.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  603.             param.ranges.def = 35.0f;

  604.             break;

  605.         case 1:

  606.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  607.             param.name = "Drive";

  608.             param.ranges.def = 56.0f;

  609.             break;

  610.         case 2:

  611.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  612.             param.name = "Level";

  613.             param.ranges.def = 70.0f;

  614.             break;

  615.         case 3:

  616.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  617.             param.name = "Type";

  618.             param.ranges.def = 0.0f;

  619.             param.ranges.max = 13.0f;

  620.             param.scalePointCount = 14;

  621.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  650.             break;

  651.         case 4:

  652.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  653.             param.name = "Negate";

  654.             param.ranges.def = 0.0f;

  655.             param.ranges.max = 1.0f;

  656.             break;

  657.         case 5:

  658.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  660.             param.ranges.def = 96.0f;

  661.             break;

  662.         case 6:

  663.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  665.             param.ranges.def = 0.0f;

  666.             break;

  667.         case 7:

  668.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  669.             param.name = "Stereo";

  670.             param.ranges.def = 0.0f;

  671.             param.ranges.max = 1.0f;

  672.             break;

  673.         case 8:

  674.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  676.             param.ranges.def = 0.0f;

  677.             param.ranges.max = 1.0f;

  678.             break;

  679.         }

  680. 

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

  682. 

  683.         return &param;

  684.     }

  685. 

  686.     // -------------------------------------------------------------------

  687.     // Plugin midi-program calls

  688. 

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

  690.     {

  691.         if (index >= fProgramCount)

  692.             return nullptr;

  693. 

  694.         static NativeMidiProgram midiProg;

  695. 

  696.         midiProg.bank    = 0;

  697.         midiProg.program = index;

  698. 

  699.         switch (index)

  700.         {

  701.         case 0:

  702.             midiProg.name = "Overdrive 1";

  703.             break;

  704.         case 1:

  705.             midiProg.name = "Overdrive 2";

  706.             break;

  707.         case 2:

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

  709.             break;

  710.         case 3:

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

  712.             break;

  713.         case 4:

  714.             midiProg.name = "Guitar Amp";

  715.             break;

  716.         case 5:

  717.             midiProg.name = "Quantisize";

  718.             break;

  719.         default:

  720.             midiProg.name = nullptr;

  721.             break;

  722.         }

  723. 

  724.         return &midiProg;

  725.     }

  726. 

  727.     // -------------------------------------------------------------------

  728. 

  729.     PluginClassEND(FxDistortionPlugin)

  730.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  731. };

  732. 

  733. // -----------------------------------------------------------------------

  734. 

  735. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  736. {

  737. public:

  738.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

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

  740. 

  741. protected:

  742.     // -------------------------------------------------------------------

  743.     // Plugin parameter calls

  744. 

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

  746.     {

  747.         if (index >= fParamCount)

  748.             return nullptr;

  749. 

  750.         static NativeParameter param;

  751.         static NativeParameterScalePoint scalePoints[2];

  752. 

  753.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  754. 

  755.         param.name = nullptr;

  756.         param.unit = nullptr;

  757.         param.ranges.def       = 1.0f;

  758.         param.ranges.min       = 0.0f;

  759.         param.ranges.max       = 127.0f;

  760.         param.ranges.step      = 1.0f;

  761.         param.ranges.stepSmall = 1.0f;

  762.         param.ranges.stepLarge = 20.0f;

  763.         param.scalePointCount  = 0;

  764.         param.scalePoints      = nullptr;

  765. 

  766.         switch (index)

  767.         {

  768.         case 0:

  769.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  770.             param.name = "LFO Frequency";

  771.             param.ranges.def = 80.0f;

  772.             break;

  773.         case 1:

  774.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  775.             param.name = "LFO Randomness";

  776.             param.ranges.def = 0.0f;

  777.             break;

  778.         case 2:

  779.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  780.             param.name = "LFO Type";

  781.             param.ranges.def = 0.0f;

  782.             param.ranges.max = 1.0f;

  783.             param.scalePointCount = 2;

  784.             param.scalePoints     = scalePoints;

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

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

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

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

  789.             break;

  790.         case 3:

  791.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  792.             param.name = "LFO Stereo";

  793.             param.ranges.def = 64.0f;

  794.             break;

  795.         case 4:

  796.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  797.             param.name = "LFO Depth";

  798.             param.ranges.def = 0.0f;

  799.             break;

  800.         case 5:

  801.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  802.             param.name = "Amp sns";

  803.             param.ranges.def = 90.0f;

  804.             break;

  805.         case 6:

  806.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  808.             param.ranges.def = 0.0f;

  809.             param.ranges.max = 1.0f;

  810.             break;

  811.         case 7:

  812.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  813.             param.name = "Amp Smooth";

  814.             param.ranges.def = 60.0f;

  815.             break;

  816.         }

  817. 

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

  819. 

  820.         return &param;

  821.     }

  822. 

  823.     // -------------------------------------------------------------------

  824.     // Plugin midi-program calls

  825. 

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

  827.     {

  828.         if (index >= fProgramCount)

  829.             return nullptr;

  830. 

  831.         static NativeMidiProgram midiProg;

  832. 

  833.         midiProg.bank    = 0;

  834.         midiProg.program = index;

  835. 

  836.         switch (index)

  837.         {

  838.         case 0:

  839.             midiProg.name = "WahWah";

  840.             break;

  841.         case 1:

  842.             midiProg.name = "AutoWah";

  843.             break;

  844.         case 2:

  845.             midiProg.name = "Sweep";

  846.             break;

  847.         case 3:

  848.             midiProg.name = "VocalMorph1";

  849.             break;

  850.         case 4:

  851.             midiProg.name = "VocalMorph2";

  852.             break;

  853.         default:

  854.             midiProg.name = nullptr;

  855.             break;

  856.         }

  857. 

  858.         return &midiProg;

  859.     }

  860. 

  861.     // -------------------------------------------------------------------

  862. 

  863.     PluginClassEND(FxDynamicFilterPlugin)

  864.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  865. };

  866. 

  867. // -----------------------------------------------------------------------

  868. 

  869. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  870. {

  871. public:

  872.     FxEchoPlugin(const NativeHostDescriptor* const host)

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

  874. 

  875. protected:

  876.     // -------------------------------------------------------------------

  877.     // Plugin parameter calls

  878. 

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

  880.     {

  881.         if (index >= fParamCount)

  882.             return nullptr;

  883. 

  884.         static NativeParameter param;

  885. 

  886.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  887. 

  888.         param.name = nullptr;

  889.         param.unit = nullptr;

  890.         param.ranges.def       = 1.0f;

  891.         param.ranges.min       = 0.0f;

  892.         param.ranges.max       = 127.0f;

  893.         param.ranges.step      = 1.0f;

  894.         param.ranges.stepSmall = 1.0f;

  895.         param.ranges.stepLarge = 20.0f;

  896.         param.scalePointCount  = 0;

  897.         param.scalePoints      = nullptr;

  898. 

  899.         switch (index)

  900.         {

  901.         case 0:

  902.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  903.             param.name = "Delay";

  904.             param.ranges.def = 35.0f;

  905.             break;

  906.         case 1:

  907.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  909.             param.ranges.def = 64.0f;

  910.             break;

  911.         case 2:

  912.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  914.             param.ranges.def = 30.0f;

  915.             break;

  916.         case 3:

  917.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  918.             param.name = "Feedback";

  919.             param.ranges.def = 59.0f;

  920.             break;

  921.         case 4:

  922.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  923.             param.name = "High Damp";

  924.             param.ranges.def = 0.0f;

  925.             break;

  926.         }

  927. 

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

  929. 

  930.         return &param;

  931.     }

  932. 

  933.     // -------------------------------------------------------------------

  934.     // Plugin midi-program calls

  935. 

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

  937.     {

  938.         if (index >= fProgramCount)

  939.             return nullptr;

  940. 

  941.         static NativeMidiProgram midiProg;

  942. 

  943.         midiProg.bank    = 0;

  944.         midiProg.program = index;

  945. 

  946.         switch (index)

  947.         {

  948.         case 0:

  949.             midiProg.name = "Echo 1";

  950.             break;

  951.         case 1:

  952.             midiProg.name = "Echo 2";

  953.             break;

  954.         case 2:

  955.             midiProg.name = "Echo 3";

  956.             break;

  957.         case 3:

  958.             midiProg.name = "Simple Echo";

  959.             break;

  960.         case 4:

  961.             midiProg.name = "Canyon";

  962.             break;

  963.         case 5:

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

  965.             break;

  966.         case 6:

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

  968.             break;

  969.         case 7:

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

  971.             break;

  972.         case 8:

  973.             midiProg.name = "Feedback Echo";

  974.             break;

  975.         default:

  976.             midiProg.name = nullptr;

  977.             break;

  978.         }

  979. 

  980.         return &midiProg;

  981.     }

  982. 

  983.     // -------------------------------------------------------------------

  984. 

  985.     PluginClassEND(FxEchoPlugin)

  986.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  987. };

  988. 

  989. // -----------------------------------------------------------------------

  990. 

  991. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  992. {

  993. public:

  994.     FxPhaserPlugin(const NativeHostDescriptor* const host)

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

  996. 

  997. protected:

  998.     // -------------------------------------------------------------------

  999.     // Plugin parameter calls

  1000. 

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

  1002.     {

  1003.         if (index >= fParamCount)

  1004.             return nullptr;

  1005. 

  1006.         static NativeParameter param;

  1007.         static NativeParameterScalePoint scalePoints[2];

  1008. 

  1009.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1010. 

  1011.         param.name = nullptr;

  1012.         param.unit = nullptr;

  1013.         param.ranges.def       = 1.0f;

  1014.         param.ranges.min       = 0.0f;

  1015.         param.ranges.max       = 127.0f;

  1016.         param.ranges.step      = 1.0f;

  1017.         param.ranges.stepSmall = 1.0f;

  1018.         param.ranges.stepLarge = 20.0f;

  1019.         param.scalePointCount  = 0;

  1020.         param.scalePoints      = nullptr;

  1021. 

  1022.         switch (index)

  1023.         {

  1024.         case 0:

  1025.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1026.             param.name = "LFO Frequency";

  1027.             param.ranges.def = 36.0f;

  1028.             break;

  1029.         case 1:

  1030.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1031.             param.name = "LFO Randomness";

  1032.             param.ranges.def = 0.0f;

  1033.             break;

  1034.         case 2:

  1035.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1036.             param.name = "LFO Type";

  1037.             param.ranges.def = 0.0f;

  1038.             param.ranges.max = 1.0f;

  1039.             param.scalePointCount = 2;

  1040.             param.scalePoints     = scalePoints;

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

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

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

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

  1045.             break;

  1046.         case 3:

  1047.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1048.             param.name = "LFO Stereo";

  1049.             param.ranges.def = 64.0f;

  1050.             break;

  1051.         case 4:

  1052.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1053.             param.name = "Depth";

  1054.             param.ranges.def = 110.0f;

  1055.             break;

  1056.         case 5:

  1057.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1058.             param.name = "Feedback";

  1059.             param.ranges.def = 64.0f;

  1060.             break;

  1061.         case 6:

  1062.             param.name = "Stages";

  1063.             param.ranges.def = 1.0f;

  1064.             param.ranges.min = 1.0f;

  1065.             param.ranges.max = 12.0f;

  1066.             break;

  1067.         case 7:

  1068.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1070.             param.ranges.def = 0.0f;

  1071.             break;

  1072.         case 8:

  1073.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1074.             param.name = "Subtract Output";

  1075.             param.ranges.def = 0.0f;

  1076.             param.ranges.max = 1.0f;

  1077.             break;

  1078.         case 9:

  1079.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1081.             param.ranges.def = 20.0f;

  1082.             break;

  1083.         case 10:

  1084.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1085.             param.name = "Hyper";

  1086.             param.ranges.def = 0.0f;

  1087.             param.ranges.max = 1.0f;

  1088.             break;

  1089.         case 11:

  1090.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1091.             param.name = "Distortion";

  1092.             param.ranges.def = 0.0f;

  1093.             break;

  1094.         case 12:

  1095.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1096.             param.name = "Analog";

  1097.             param.ranges.def = 0.0f;

  1098.             param.ranges.max = 1.0f;

  1099.             break;

  1100.         }

  1101. 

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

  1103. 

  1104.         return &param;

  1105.     }

  1106. 

  1107.     // -------------------------------------------------------------------

  1108.     // Plugin midi-program calls

  1109. 

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

  1111.     {

  1112.         if (index >= fProgramCount)

  1113.             return nullptr;

  1114. 

  1115.         static NativeMidiProgram midiProg;

  1116. 

  1117.         midiProg.bank    = 0;

  1118.         midiProg.program = index;

  1119. 

  1120.         switch (index)

  1121.         {

  1122.         case 0:

  1123.             midiProg.name = "Phaser 1";

  1124.             break;

  1125.         case 1:

  1126.             midiProg.name = "Phaser 2";

  1127.             break;

  1128.         case 2:

  1129.             midiProg.name = "Phaser 3";

  1130.             break;

  1131.         case 3:

  1132.             midiProg.name = "Phaser 4";

  1133.             break;

  1134.         case 4:

  1135.             midiProg.name = "Phaser 5";

  1136.             break;

  1137.         case 5:

  1138.             midiProg.name = "Phaser 6";

  1139.             break;

  1140.         case 6:

  1141.             midiProg.name = "APhaser 1";

  1142.             break;

  1143.         case 7:

  1144.             midiProg.name = "APhaser 2";

  1145.             break;

  1146.         case 8:

  1147.             midiProg.name = "APhaser 3";

  1148.             break;

  1149.         case 9:

  1150.             midiProg.name = "APhaser 4";

  1151.             break;

  1152.         case 10:

  1153.             midiProg.name = "APhaser 5";

  1154.             break;

  1155.         case 11:

  1156.             midiProg.name = "APhaser 6";

  1157.             break;

  1158.         default:

  1159.             midiProg.name = nullptr;

  1160.             break;

  1161.         }

  1162. 

  1163.         return &midiProg;

  1164.     }

  1165. 

  1166.     // -------------------------------------------------------------------

  1167. 

  1168.     PluginClassEND(FxPhaserPlugin)

  1169.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1170. };

  1171. 

  1172. // -----------------------------------------------------------------------

  1173. 

  1174. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1175. {

  1176. public:

  1177.     FxReverbPlugin(const NativeHostDescriptor* const host)

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

  1179. 

  1180. protected:

  1181.     // -------------------------------------------------------------------

  1182.     // Plugin parameter calls

  1183. 

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

  1185.     {

  1186.         if (index >= fParamCount)

  1187.             return nullptr;

  1188. 

  1189.         static NativeParameter param;

  1190.         static NativeParameterScalePoint scalePoints[3];

  1191. 

  1192.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1193. 

  1194.         param.name = nullptr;

  1195.         param.unit = nullptr;

  1196.         param.ranges.def       = 1.0f;

  1197.         param.ranges.min       = 0.0f;

  1198.         param.ranges.max       = 127.0f;

  1199.         param.ranges.step      = 1.0f;

  1200.         param.ranges.stepSmall = 1.0f;

  1201.         param.ranges.stepLarge = 20.0f;

  1202.         param.scalePointCount  = 0;

  1203.         param.scalePoints      = nullptr;

  1204. 

  1205.         switch (index)

  1206.         {

  1207.         case 0:

  1208.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1209.             param.name = "Time";

  1210.             param.ranges.def = 63.0f;

  1211.             break;

  1212.         case 1:

  1213.             param.name = "Delay";

  1214.             param.ranges.def = 24.0f;

  1215.             break;

  1216.         case 2:

  1217.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1218.             param.name = "Feedback";

  1219.             param.ranges.def = 0.0f;

  1220.             break;

  1221.         case 3:

  1222.             hints = 0x0;

  1223.             param.name = "bw";

  1224.             break;

  1225.         case 4:

  1226.             hints = 0x0;

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

  1228.             break;

  1229.         case 5:

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

  1231.             param.ranges.def = 85.0f;

  1232.             break;

  1233.         case 6:

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

  1235.             param.ranges.def = 5.0f;

  1236.             break;

  1237.         case 7:

  1238.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1239.             param.name = "Damp";

  1240.             param.ranges.def = 83.0f;

  1241.             param.ranges.min = 64.0f;

  1242.             break;

  1243.         case 8:

  1244.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1245.             param.name = "Type";

  1246.             param.ranges.def = 1.0f;

  1247.             param.ranges.max = 2.0f;

  1248.             param.scalePointCount = 3;

  1249.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1256.             break;

  1257.         case 9:

  1258.             param.name = "Room size";

  1259.             param.ranges.def = 64.0f;

  1260.             param.ranges.min = 1.0f;

  1261.             break;

  1262.         case 10:

  1263.             param.name = "Bandwidth";

  1264.             param.ranges.def = 20.0f;

  1265.             break;

  1266.         }

  1267. 

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

  1269. 

  1270.         return &param;

  1271.     }

  1272. 

  1273.     // -------------------------------------------------------------------

  1274.     // Plugin midi-program calls

  1275. 

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

  1277.     {

  1278.         if (index >= fProgramCount)

  1279.             return nullptr;

  1280. 

  1281.         static NativeMidiProgram midiProg;

  1282. 

  1283.         midiProg.bank    = 0;

  1284.         midiProg.program = index;

  1285. 

  1286.         switch (index)

  1287.         {

  1288.         case 0:

  1289.             midiProg.name = "Cathedral1";

  1290.             break;

  1291.         case 1:

  1292.             midiProg.name = "Cathedral2";

  1293.             break;

  1294.         case 2:

  1295.             midiProg.name = "Cathedral3";

  1296.             break;

  1297.         case 3:

  1298.             midiProg.name = "Hall1";

  1299.             break;

  1300.         case 4:

  1301.             midiProg.name = "Hall2";

  1302.             break;

  1303.         case 5:

  1304.             midiProg.name = "Room1";

  1305.             break;

  1306.         case 6:

  1307.             midiProg.name = "Room2";

  1308.             break;

  1309.         case 7:

  1310.             midiProg.name = "Basement";

  1311.             break;

  1312.         case 8:

  1313.             midiProg.name = "Tunnel";

  1314.             break;

  1315.         case 9:

  1316.             midiProg.name = "Echoed1";

  1317.             break;

  1318.         case 10:

  1319.             midiProg.name = "Echoed2";

  1320.             break;

  1321.         case 11:

  1322.             midiProg.name = "VeryLong1";

  1323.             break;

  1324.         case 12:

  1325.             midiProg.name = "VeryLong2";

  1326.             break;

  1327.         default:

  1328.             midiProg.name = nullptr;

  1329.             break;

  1330.         }

  1331. 

  1332.         return &midiProg;

  1333.     }

  1334. 

  1335.     // -------------------------------------------------------------------

  1336. 

  1337.     PluginClassEND(FxReverbPlugin)

  1338.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1339. };

  1340. 

  1341. // -----------------------------------------------------------------------

  1342. 

  1343. static const NativePluginDescriptor fxAlienWahDesc = {

  1344.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1346.                                                   |NATIVE_PLUGIN_USES_PANNING

  1347.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1348.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1349.     /* audioIns  */ 2,

  1350.     /* audioOuts */ 2,

  1351.     /* midiIns   */ 0,

  1352.     /* midiOuts  */ 0,

  1353.     /* paramIns  */ 11-2,

  1354.     /* paramOuts */ 0,

  1355.     /* name      */ "ZynAlienWah",

  1356.     /* label     */ "zynalienwah",

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

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

  1359.     PluginDescriptorFILL(FxAlienWahPlugin)

  1360. };

  1361. 

  1362. static const NativePluginDescriptor fxChorusDesc = {

  1363.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1365.                                                   |NATIVE_PLUGIN_USES_PANNING

  1366.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1367.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1368.     /* audioIns  */ 2,

  1369.     /* audioOuts */ 2,

  1370.     /* midiIns   */ 0,

  1371.     /* midiOuts  */ 0,

  1372.     /* paramIns  */ 12-2,

  1373.     /* paramOuts */ 0,

  1374.     /* name      */ "ZynChorus",

  1375.     /* label     */ "zynchorus",

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

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

  1378.     PluginDescriptorFILL(FxChorusPlugin)

  1379. };

  1380. 

  1381. static const NativePluginDescriptor fxDistortionDesc = {

  1382.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1384.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1385.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1386.     /* audioIns  */ 2,

  1387.     /* audioOuts */ 2,

  1388.     /* midiIns   */ 0,

  1389.     /* midiOuts  */ 0,

  1390.     /* paramIns  */ 11-2,

  1391.     /* paramOuts */ 0,

  1392.     /* name      */ "ZynDistortion",

  1393.     /* label     */ "zyndistortion",

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

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

  1396.     PluginDescriptorFILL(FxDistortionPlugin)

  1397. };

  1398. 

  1399. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1400.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1402.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1403.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1404.     /* audioIns  */ 2,

  1405.     /* audioOuts */ 2,

  1406.     /* midiIns   */ 0,

  1407.     /* midiOuts  */ 0,

  1408.     /* paramIns  */ 10-2,

  1409.     /* paramOuts */ 0,

  1410.     /* name      */ "ZynDynamicFilter",

  1411.     /* label     */ "zyndynamicfilter",

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

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

  1414.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1415. };

  1416. 

  1417. static const NativePluginDescriptor fxEchoDesc = {

  1418.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1420.                                                   |NATIVE_PLUGIN_USES_PANNING

  1421.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1422.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1423.     /* audioIns  */ 2,

  1424.     /* audioOuts */ 2,

  1425.     /* midiIns   */ 0,

  1426.     /* midiOuts  */ 0,

  1427.     /* paramIns  */ 7-2,

  1428.     /* paramOuts */ 0,

  1429.     /* name      */ "ZynEcho",

  1430.     /* label     */ "zynecho",

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

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

  1433.     PluginDescriptorFILL(FxEchoPlugin)

  1434. };

  1435. 

  1436. static const NativePluginDescriptor fxPhaserDesc = {

  1437.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1439.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1440.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1441.     /* audioIns  */ 2,

  1442.     /* audioOuts */ 2,

  1443.     /* midiIns   */ 0,

  1444.     /* midiOuts  */ 0,

  1445.     /* paramIns  */ 15-2,

  1446.     /* paramOuts */ 0,

  1447.     /* name      */ "ZynPhaser",

  1448.     /* label     */ "zynphaser",

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

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

  1451.     PluginDescriptorFILL(FxPhaserPlugin)

  1452. };

  1453. 

  1454. static const NativePluginDescriptor fxReverbDesc = {

  1455.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1457.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1458.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1459.     /* audioIns  */ 2,

  1460.     /* audioOuts */ 2,

  1461.     /* midiIns   */ 0,

  1462.     /* midiOuts  */ 0,

  1463.     /* paramIns  */ 13-2,

  1464.     /* paramOuts */ 0,

  1465.     /* name      */ "ZynReverb",

  1466.     /* label     */ "zynreverb",

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

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

  1469.     PluginDescriptorFILL(FxReverbPlugin)

  1470. };

  1471. 

  1472. // -----------------------------------------------------------------------

  1473. 

  1474. CARLA_EXPORT

  1475. void carla_register_native_plugin_zynaddsubfx_fx();

  1476. 

  1477. CARLA_EXPORT

  1478. void carla_register_native_plugin_zynaddsubfx_fx()

  1479. {

  1480.     carla_register_native_plugin(&fxAlienWahDesc);

  1481.     carla_register_native_plugin(&fxChorusDesc);

  1482.     carla_register_native_plugin(&fxDistortionDesc);

  1483.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1484.     carla_register_native_plugin(&fxEchoDesc);

  1485.     carla_register_native_plugin(&fxPhaserDesc);

  1486.     carla_register_native_plugin(&fxReverbDesc);

  1487. }

  1488. 

  1489. // -----------------------------------------------------------------------