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

1458 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.h"

  31. using juce::roundToIntAccurate;

  32. using juce::FloatVectorOperations;

  33. using juce::SharedResourcePointer;

  34. 

  35. // -----------------------------------------------------------------------

  36. 

  37. template<class ZynFX>

  38. class FxAbstractPlugin : public NativePluginClass

  39. {

  40. protected:

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

  42.         : NativePluginClass(host),

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

  44.           fProgramCount(programCount),

  45.           fBufferSize(getBufferSize()),

  46.           fSampleRate(getSampleRate()),

  47.           fEffect(nullptr),

  48.           efxoutl(nullptr),

  49.           efxoutr(nullptr),

  50.           leakDetector_FxAbstractPlugin()

  51.     {

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

  53. 

  54.         efxoutl = new float[fBufferSize];

  55.         efxoutr = new float[fBufferSize];

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

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

  58. 

  59.         doReinit(true);

  60.     }

  61. 

  62.     ~FxAbstractPlugin() override

  63.     {

  64.         if (efxoutl != nullptr)

  65.         {

  66.             delete[] efxoutl;

  67.             efxoutl = nullptr;

  68.         }

  69. 

  70.         if (efxoutr != nullptr)

  71.         {

  72.             delete[] efxoutr;

  73.             efxoutr = nullptr;

  74.         }

  75. 

  76.         if (fEffect != nullptr)

  77.         {

  78.             delete fEffect;

  79.             fEffect = nullptr;

  80.         }

  81.     }

  82. 

  83.     // -------------------------------------------------------------------

  84.     // Plugin parameter calls

  85. 

  86.     uint32_t getParameterCount() const final

  87.     {

  88.         return fParamCount;

  89.     }

  90. 

  91.     float getParameterValue(const uint32_t index) const final

  92.     {

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

  94.     }

  95. 

  96.     // -------------------------------------------------------------------

  97.     // Plugin midi-program calls

  98. 

  99.     uint32_t getMidiProgramCount() const final

  100.     {

  101.         return fProgramCount;

  102.     }

  103. 

  104.     // -------------------------------------------------------------------

  105.     // Plugin state calls

  106. 

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

  108.     {

  109.         const int ivalue(roundToIntAccurate(carla_fixValue(0.0f, 127.0f, value)));

  110. 

  111.         fEffect->changepar(static_cast<int>(index+2), static_cast<uchar>(ivalue));

  112.     }

  113. 

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

  115.     {

  116.         fEffect->setpreset(static_cast<uchar>(program));

  117. 

  118.         // reset volume and pan

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

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

  121.     }

  122. 

  123.     // -------------------------------------------------------------------

  124.     // Plugin process calls

  125. 

  126.     void activate() final

  127.     {

  128.         fEffect->cleanup();

  129.     }

  130. 

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

  132.     {

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

  134. 

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

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

  137.         else

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

  139. 

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

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

  142.         else

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

  144. 

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

  146. 

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

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

  149.     }

  150. 

  151.     // -------------------------------------------------------------------

  152.     // Plugin dispatcher

  153. 

  154.     void bufferSizeChanged(const uint32_t bufferSize) final

  155.     {

  156.         if (fBufferSize == bufferSize)

  157.             return;

  158. 

  159.         fBufferSize = bufferSize;

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

  161. 

  162.         delete[] efxoutl;

  163.         delete[] efxoutr;

  164.         efxoutl = new float[bufferSize];

  165.         efxoutr = new float[bufferSize];

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

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

  168. 

  169.         doReinit(false);

  170.     }

  171. 

  172.     void sampleRateChanged(const double sampleRate) final

  173.     {

  174.         if (fSampleRate == sampleRate)

  175.             return;

  176. 

  177.         fSampleRate = sampleRate;

  178. 

  179.         doReinit(false);

  180.     }

  181. 

  182.     void doReinit(const bool firstInit)

  183.     {

  184.         uchar params[fParamCount];

  185. 

  186.         if (fEffect != nullptr)

  187.         {

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

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

  190. 

  191.             delete fEffect;

  192.         }

  193. 

  194.         EffectParams pars(fAllocator.getObject(), false, efxoutl, efxoutr, 0, static_cast<uint>(fSampleRate), static_cast<int>(fBufferSize));

  195.         fEffect = new ZynFX(pars);

  196. 

  197.         if (firstInit)

  198.         {

  199.             fEffect->setpreset(0);

  200.         }

  201.         else

  202.         {

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

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

  205.         }

  206. 

  207.         // reset volume and pan

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

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

  210.     }

  211. 

  212.     // -------------------------------------------------------------------

  213. 

  214.     const uint32_t fParamCount;

  215.     const uint32_t fProgramCount;

  216. 

  217.     uint32_t fBufferSize;

  218.     double   fSampleRate;

  219. 

  220.     Effect* fEffect;

  221.     float*  efxoutl;

  222.     float*  efxoutr;

  223. 

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

  225.     SharedResourcePointer<Allocator> fAllocator;

  226. 

  227.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  228. };

  229. 

  230. // -----------------------------------------------------------------------

  231. 

  232. class FxAlienWahPlugin : public FxAbstractPlugin<Alienwah>

  233. {

  234. public:

  235.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

  236.         : FxAbstractPlugin(host, 11, 4),

  237.           leakDetector_FxAlienWahPlugin() {}

  238. 

  239. protected:

  240.     // -------------------------------------------------------------------

  241.     // Plugin parameter calls

  242. 

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

  244.     {

  245.         if (index >= fParamCount)

  246.             return nullptr;

  247. 

  248.         static NativeParameter param;

  249.         static NativeParameterScalePoint scalePoints[2];

  250. 

  251.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  252. 

  253.         param.name = nullptr;

  254.         param.unit = nullptr;

  255.         param.ranges.def       = 1.0f;

  256.         param.ranges.min       = 0.0f;

  257.         param.ranges.max       = 127.0f;

  258.         param.ranges.step      = 1.0f;

  259.         param.ranges.stepSmall = 1.0f;

  260.         param.ranges.stepLarge = 20.0f;

  261.         param.scalePointCount  = 0;

  262.         param.scalePoints      = nullptr;

  263. 

  264.         switch (index)

  265.         {

  266.         case 0:

  267.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  268.             param.name = "LFO Frequency";

  269.             param.ranges.def = 70.0f;

  270.             break;

  271.         case 1:

  272.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  273.             param.name = "LFO Randomness";

  274.             param.ranges.def = 0.0f;

  275.             break;

  276.         case 2:

  277.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  278.             param.name = "LFO Type";

  279.             param.ranges.def = 0.0f;

  280.             param.ranges.max = 1.0f;

  281.             param.scalePointCount = 2;

  282.             param.scalePoints     = scalePoints;

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

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

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

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

  287.             break;

  288.         case 3:

  289.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  290.             param.name = "LFO Stereo";

  291.             param.ranges.def = 62.0f;

  292.             break;

  293.         case 4:

  294.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  295.             param.name = "Depth";

  296.             param.ranges.def = 60.0f;

  297.             break;

  298.         case 5:

  299.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  300.             param.name = "Feedback";

  301.             param.ranges.def = 105.0f;

  302.             break;

  303.         case 6:

  304.             param.name = "Delay";

  305.             param.ranges.def = 25.0f;

  306.             param.ranges.min = 1.0f;

  307.             param.ranges.max = 100.0f;

  308.             break;

  309.         case 7:

  310.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  312.             param.ranges.def = 0.0f;

  313.             break;

  314.         case 8:

  315.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  316.             param.name = "Phase";

  317.             param.ranges.def = 64.0f;

  318.             break;

  319.         }

  320. 

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

  322. 

  323.         return &param;

  324.     }

  325. 

  326.     // -------------------------------------------------------------------

  327.     // Plugin midi-program calls

  328. 

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

  330.     {

  331.         if (index >= fProgramCount)

  332.             return nullptr;

  333. 

  334.         static NativeMidiProgram midiProg;

  335. 

  336.         midiProg.bank    = 0;

  337.         midiProg.program = index;

  338. 

  339.         switch (index)

  340.         {

  341.         case 0:

  342.             midiProg.name = "AlienWah1";

  343.             break;

  344.         case 1:

  345.             midiProg.name = "AlienWah2";

  346.             break;

  347.         case 2:

  348.             midiProg.name = "AlienWah3";

  349.             break;

  350.         case 3:

  351.             midiProg.name = "AlienWah4";

  352.             break;

  353.         default:

  354.             midiProg.name = nullptr;

  355.             break;

  356.         }

  357. 

  358.         return &midiProg;

  359.     }

  360. 

  361.     // -------------------------------------------------------------------

  362. 

  363.     PluginClassEND(FxAlienWahPlugin)

  364.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  365. };

  366. 

  367. // -----------------------------------------------------------------------

  368. 

  369. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  370. {

  371. public:

  372.     FxChorusPlugin(const NativeHostDescriptor* const host)

  373.         : FxAbstractPlugin(host, 12, 10),

  374.           leakDetector_FxChorusPlugin() {}

  375. 

  376. protected:

  377.     // -------------------------------------------------------------------

  378.     // Plugin parameter calls

  379. 

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

  381.     {

  382.         if (index >= fParamCount)

  383.             return nullptr;

  384. 

  385.         static NativeParameter param;

  386.         static NativeParameterScalePoint scalePoints[2];

  387. 

  388.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  389. 

  390.         param.name = nullptr;

  391.         param.unit = nullptr;

  392.         param.ranges.def       = 1.0f;

  393.         param.ranges.min       = 0.0f;

  394.         param.ranges.max       = 127.0f;

  395.         param.ranges.step      = 1.0f;

  396.         param.ranges.stepSmall = 1.0f;

  397.         param.ranges.stepLarge = 20.0f;

  398.         param.scalePointCount  = 0;

  399.         param.scalePoints      = nullptr;

  400. 

  401.         switch (index)

  402.         {

  403.         case 0:

  404.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  405.             param.name = "LFO Frequency";

  406.             param.ranges.def = 50.0f;

  407.             break;

  408.         case 1:

  409.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  410.             param.name = "LFO Randomness";

  411.             param.ranges.def = 0.0f;

  412.             break;

  413.         case 2:

  414.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  415.             param.name = "LFO Type";

  416.             param.ranges.def = 0.0f;

  417.             param.ranges.max = 1.0f;

  418.             param.scalePointCount = 2;

  419.             param.scalePoints     = scalePoints;

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

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

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

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

  424.             break;

  425.         case 3:

  426.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  427.             param.name = "LFO Stereo";

  428.             param.ranges.def = 90.0f;

  429.             break;

  430.         case 4:

  431.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  432.             param.name = "Depth";

  433.             param.ranges.def = 40.0f;

  434.             break;

  435.         case 5:

  436.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  437.             param.name = "Delay";

  438.             param.ranges.def = 85.0f;

  439.             break;

  440.         case 6:

  441.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  442.             param.name = "Feedback";

  443.             param.ranges.def = 64.0f;

  444.             break;

  445.         case 7:

  446.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  448.             param.ranges.def = 119.0f;

  449.             break;

  450.         case 8:

  451.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  452.             param.name = "Flange Mode";

  453.             param.ranges.def = 0.0f;

  454.             param.ranges.max = 1.0f;

  455.             break;

  456.         case 9:

  457.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  458.             param.name = "Subtract Output";

  459.             param.ranges.def = 0.0f;

  460.             param.ranges.max = 1.0f;

  461.             break;

  462.         }

  463. 

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

  465. 

  466.         return &param;

  467.     }

  468. 

  469.     // -------------------------------------------------------------------

  470.     // Plugin midi-program calls

  471. 

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

  473.     {

  474.         if (index >= fProgramCount)

  475.             return nullptr;

  476. 

  477.         static NativeMidiProgram midiProg;

  478. 

  479.         midiProg.bank    = 0;

  480.         midiProg.program = index;

  481. 

  482.         switch (index)

  483.         {

  484.         case 0:

  485.             midiProg.name = "Chorus1";

  486.             break;

  487.         case 1:

  488.             midiProg.name = "Chorus2";

  489.             break;

  490.         case 2:

  491.             midiProg.name = "Chorus3";

  492.             break;

  493.         case 3:

  494.             midiProg.name = "Celeste1";

  495.             break;

  496.         case 4:

  497.             midiProg.name = "Celeste2";

  498.             break;

  499.         case 5:

  500.             midiProg.name = "Flange1";

  501.             break;

  502.         case 6:

  503.             midiProg.name = "Flange2";

  504.             break;

  505.         case 7:

  506.             midiProg.name = "Flange3";

  507.             break;

  508.         case 8:

  509.             midiProg.name = "Flange4";

  510.             break;

  511.         case 9:

  512.             midiProg.name = "Flange5";

  513.             break;

  514.         default:

  515.             midiProg.name = nullptr;

  516.             break;

  517.         }

  518. 

  519.         return &midiProg;

  520.     }

  521. 

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

  523. 

  524.     PluginClassEND(FxChorusPlugin)

  525.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  526. };

  527. 

  528. // -----------------------------------------------------------------------

  529. 

  530. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  531. {

  532. public:

  533.     FxDistortionPlugin(const NativeHostDescriptor* const host)

  534.         : FxAbstractPlugin(host, 11, 6),

  535.           leakDetector_FxDistortionPlugin() {}

  536. 

  537. protected:

  538.     // -------------------------------------------------------------------

  539.     // Plugin parameter calls

  540. 

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

  542.     {

  543.         if (index >= fParamCount)

  544.             return nullptr;

  545. 

  546.         static NativeParameter param;

  547.         static NativeParameterScalePoint scalePoints[14];

  548. 

  549.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  550. 

  551.         param.name = nullptr;

  552.         param.unit = nullptr;

  553.         param.ranges.def       = 1.0f;

  554.         param.ranges.min       = 0.0f;

  555.         param.ranges.max       = 127.0f;

  556.         param.ranges.step      = 1.0f;

  557.         param.ranges.stepSmall = 1.0f;

  558.         param.ranges.stepLarge = 20.0f;

  559.         param.scalePointCount  = 0;

  560.         param.scalePoints      = nullptr;

  561. 

  562.         switch (index)

  563.         {

  564.         case 0:

  565.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  567.             param.ranges.def = 35.0f;

  568.             break;

  569.         case 1:

  570.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  571.             param.name = "Drive";

  572.             param.ranges.def = 56.0f;

  573.             break;

  574.         case 2:

  575.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  576.             param.name = "Level";

  577.             param.ranges.def = 70.0f;

  578.             break;

  579.         case 3:

  580.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  581.             param.name = "Type";

  582.             param.ranges.def = 0.0f;

  583.             param.ranges.max = 13.0f;

  584.             param.scalePointCount = 14;

  585.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  614.             break;

  615.         case 4:

  616.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  617.             param.name = "Negate";

  618.             param.ranges.def = 0.0f;

  619.             param.ranges.max = 1.0f;

  620.             break;

  621.         case 5:

  622.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  624.             param.ranges.def = 96.0f;

  625.             break;

  626.         case 6:

  627.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  629.             param.ranges.def = 0.0f;

  630.             break;

  631.         case 7:

  632.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  633.             param.name = "Stereo";

  634.             param.ranges.def = 0.0f;

  635.             param.ranges.max = 1.0f;

  636.             break;

  637.         case 8:

  638.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  640.             param.ranges.def = 0.0f;

  641.             param.ranges.max = 1.0f;

  642.             break;

  643.         }

  644. 

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

  646. 

  647.         return &param;

  648.     }

  649. 

  650.     // -------------------------------------------------------------------

  651.     // Plugin midi-program calls

  652. 

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

  654.     {

  655.         if (index >= fProgramCount)

  656.             return nullptr;

  657. 

  658.         static NativeMidiProgram midiProg;

  659. 

  660.         midiProg.bank    = 0;

  661.         midiProg.program = index;

  662. 

  663.         switch (index)

  664.         {

  665.         case 0:

  666.             midiProg.name = "Overdrive 1";

  667.             break;

  668.         case 1:

  669.             midiProg.name = "Overdrive 2";

  670.             break;

  671.         case 2:

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

  673.             break;

  674.         case 3:

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

  676.             break;

  677.         case 4:

  678.             midiProg.name = "Guitar Amp";

  679.             break;

  680.         case 5:

  681.             midiProg.name = "Quantisize";

  682.             break;

  683.         default:

  684.             midiProg.name = nullptr;

  685.             break;

  686.         }

  687. 

  688.         return &midiProg;

  689.     }

  690. 

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

  692. 

  693.     PluginClassEND(FxDistortionPlugin)

  694.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  695. };

  696. 

  697. // -----------------------------------------------------------------------

  698. 

  699. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  700. {

  701. public:

  702.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

  703.         : FxAbstractPlugin(host, 10, 5),

  704.           leakDetector_FxDynamicFilterPlugin() {}

  705. 

  706. protected:

  707.     // -------------------------------------------------------------------

  708.     // Plugin parameter calls

  709. 

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

  711.     {

  712.         if (index >= fParamCount)

  713.             return nullptr;

  714. 

  715.         static NativeParameter param;

  716.         static NativeParameterScalePoint scalePoints[2];

  717. 

  718.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  719. 

  720.         param.name = nullptr;

  721.         param.unit = nullptr;

  722.         param.ranges.def       = 1.0f;

  723.         param.ranges.min       = 0.0f;

  724.         param.ranges.max       = 127.0f;

  725.         param.ranges.step      = 1.0f;

  726.         param.ranges.stepSmall = 1.0f;

  727.         param.ranges.stepLarge = 20.0f;

  728.         param.scalePointCount  = 0;

  729.         param.scalePoints      = nullptr;

  730. 

  731.         switch (index)

  732.         {

  733.         case 0:

  734.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  735.             param.name = "LFO Frequency";

  736.             param.ranges.def = 80.0f;

  737.             break;

  738.         case 1:

  739.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  740.             param.name = "LFO Randomness";

  741.             param.ranges.def = 0.0f;

  742.             break;

  743.         case 2:

  744.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  745.             param.name = "LFO Type";

  746.             param.ranges.def = 0.0f;

  747.             param.ranges.max = 1.0f;

  748.             param.scalePointCount = 2;

  749.             param.scalePoints     = scalePoints;

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

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

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

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

  754.             break;

  755.         case 3:

  756.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  757.             param.name = "LFO Stereo";

  758.             param.ranges.def = 64.0f;

  759.             break;

  760.         case 4:

  761.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  762.             param.name = "LFO Depth";

  763.             param.ranges.def = 0.0f;

  764.             break;

  765.         case 5:

  766.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  767.             param.name = "Amp sns";

  768.             param.ranges.def = 90.0f;

  769.             break;

  770.         case 6:

  771.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  773.             param.ranges.def = 0.0f;

  774.             param.ranges.max = 1.0f;

  775.             break;

  776.         case 7:

  777.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  778.             param.name = "Amp Smooth";

  779.             param.ranges.def = 60.0f;

  780.             break;

  781.         }

  782. 

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

  784. 

  785.         return &param;

  786.     }

  787. 

  788.     // -------------------------------------------------------------------

  789.     // Plugin midi-program calls

  790. 

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

  792.     {

  793.         if (index >= fProgramCount)

  794.             return nullptr;

  795. 

  796.         static NativeMidiProgram midiProg;

  797. 

  798.         midiProg.bank    = 0;

  799.         midiProg.program = index;

  800. 

  801.         switch (index)

  802.         {

  803.         case 0:

  804.             midiProg.name = "WahWah";

  805.             break;

  806.         case 1:

  807.             midiProg.name = "AutoWah";

  808.             break;

  809.         case 2:

  810.             midiProg.name = "Sweep";

  811.             break;

  812.         case 3:

  813.             midiProg.name = "VocalMorph1";

  814.             break;

  815.         case 4:

  816.             midiProg.name = "VocalMorph2";

  817.             break;

  818.         default:

  819.             midiProg.name = nullptr;

  820.             break;

  821.         }

  822. 

  823.         return &midiProg;

  824.     }

  825. 

  826.     // -------------------------------------------------------------------

  827. 

  828.     PluginClassEND(FxDynamicFilterPlugin)

  829.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  830. };

  831. 

  832. // -----------------------------------------------------------------------

  833. 

  834. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  835. {

  836. public:

  837.     FxEchoPlugin(const NativeHostDescriptor* const host)

  838.         : FxAbstractPlugin(host, 7, 9),

  839.           leakDetector_FxEchoPlugin() {}

  840. 

  841. protected:

  842.     // -------------------------------------------------------------------

  843.     // Plugin parameter calls

  844. 

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

  846.     {

  847.         if (index >= fParamCount)

  848.             return nullptr;

  849. 

  850.         static NativeParameter param;

  851. 

  852.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  853. 

  854.         param.name = nullptr;

  855.         param.unit = nullptr;

  856.         param.ranges.def       = 1.0f;

  857.         param.ranges.min       = 0.0f;

  858.         param.ranges.max       = 127.0f;

  859.         param.ranges.step      = 1.0f;

  860.         param.ranges.stepSmall = 1.0f;

  861.         param.ranges.stepLarge = 20.0f;

  862.         param.scalePointCount  = 0;

  863.         param.scalePoints      = nullptr;

  864. 

  865.         switch (index)

  866.         {

  867.         case 0:

  868.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  869.             param.name = "Delay";

  870.             param.ranges.def = 35.0f;

  871.             break;

  872.         case 1:

  873.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  875.             param.ranges.def = 64.0f;

  876.             break;

  877.         case 2:

  878.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  880.             param.ranges.def = 30.0f;

  881.             break;

  882.         case 3:

  883.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  884.             param.name = "Feedback";

  885.             param.ranges.def = 59.0f;

  886.             break;

  887.         case 4:

  888.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  889.             param.name = "High Damp";

  890.             param.ranges.def = 0.0f;

  891.             break;

  892.         }

  893. 

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

  895. 

  896.         return &param;

  897.     }

  898. 

  899.     // -------------------------------------------------------------------

  900.     // Plugin midi-program calls

  901. 

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

  903.     {

  904.         if (index >= fProgramCount)

  905.             return nullptr;

  906. 

  907.         static NativeMidiProgram midiProg;

  908. 

  909.         midiProg.bank    = 0;

  910.         midiProg.program = index;

  911. 

  912.         switch (index)

  913.         {

  914.         case 0:

  915.             midiProg.name = "Echo 1";

  916.             break;

  917.         case 1:

  918.             midiProg.name = "Echo 2";

  919.             break;

  920.         case 2:

  921.             midiProg.name = "Echo 3";

  922.             break;

  923.         case 3:

  924.             midiProg.name = "Simple Echo";

  925.             break;

  926.         case 4:

  927.             midiProg.name = "Canyon";

  928.             break;

  929.         case 5:

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

  931.             break;

  932.         case 6:

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

  934.             break;

  935.         case 7:

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

  937.             break;

  938.         case 8:

  939.             midiProg.name = "Feedback Echo";

  940.             break;

  941.         default:

  942.             midiProg.name = nullptr;

  943.             break;

  944.         }

  945. 

  946.         return &midiProg;

  947.     }

  948. 

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

  950. 

  951.     PluginClassEND(FxEchoPlugin)

  952.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  953. };

  954. 

  955. // -----------------------------------------------------------------------

  956. 

  957. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  958. {

  959. public:

  960.     FxPhaserPlugin(const NativeHostDescriptor* const host)

  961.         : FxAbstractPlugin(host, 15, 12),

  962.           leakDetector_FxPhaserPlugin() {}

  963. 

  964. protected:

  965.     // -------------------------------------------------------------------

  966.     // Plugin parameter calls

  967. 

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

  969.     {

  970.         if (index >= fParamCount)

  971.             return nullptr;

  972. 

  973.         static NativeParameter param;

  974.         static NativeParameterScalePoint scalePoints[2];

  975. 

  976.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  977. 

  978.         param.name = nullptr;

  979.         param.unit = nullptr;

  980.         param.ranges.def       = 1.0f;

  981.         param.ranges.min       = 0.0f;

  982.         param.ranges.max       = 127.0f;

  983.         param.ranges.step      = 1.0f;

  984.         param.ranges.stepSmall = 1.0f;

  985.         param.ranges.stepLarge = 20.0f;

  986.         param.scalePointCount  = 0;

  987.         param.scalePoints      = nullptr;

  988. 

  989.         switch (index)

  990.         {

  991.         case 0:

  992.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  993.             param.name = "LFO Frequency";

  994.             param.ranges.def = 36.0f;

  995.             break;

  996.         case 1:

  997.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  998.             param.name = "LFO Randomness";

  999.             param.ranges.def = 0.0f;

  1000.             break;

  1001.         case 2:

  1002.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1003.             param.name = "LFO Type";

  1004.             param.ranges.def = 0.0f;

  1005.             param.ranges.max = 1.0f;

  1006.             param.scalePointCount = 2;

  1007.             param.scalePoints     = scalePoints;

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

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

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

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

  1012.             break;

  1013.         case 3:

  1014.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1015.             param.name = "LFO Stereo";

  1016.             param.ranges.def = 64.0f;

  1017.             break;

  1018.         case 4:

  1019.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1020.             param.name = "Depth";

  1021.             param.ranges.def = 110.0f;

  1022.             break;

  1023.         case 5:

  1024.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1025.             param.name = "Feedback";

  1026.             param.ranges.def = 64.0f;

  1027.             break;

  1028.         case 6:

  1029.             param.name = "Stages";

  1030.             param.ranges.def = 1.0f;

  1031.             param.ranges.min = 1.0f;

  1032.             param.ranges.max = 12.0f;

  1033.             break;

  1034.         case 7:

  1035.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1037.             param.ranges.def = 0.0f;

  1038.             break;

  1039.         case 8:

  1040.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1041.             param.name = "Subtract Output";

  1042.             param.ranges.def = 0.0f;

  1043.             param.ranges.max = 1.0f;

  1044.             break;

  1045.         case 9:

  1046.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1048.             param.ranges.def = 20.0f;

  1049.             break;

  1050.         case 10:

  1051.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1052.             param.name = "Hyper";

  1053.             param.ranges.def = 0.0f;

  1054.             param.ranges.max = 1.0f;

  1055.             break;

  1056.         case 11:

  1057.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1058.             param.name = "Distortion";

  1059.             param.ranges.def = 0.0f;

  1060.             break;

  1061.         case 12:

  1062.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1063.             param.name = "Analog";

  1064.             param.ranges.def = 0.0f;

  1065.             param.ranges.max = 1.0f;

  1066.             break;

  1067.         }

  1068. 

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

  1070. 

  1071.         return &param;

  1072.     }

  1073. 

  1074.     // -------------------------------------------------------------------

  1075.     // Plugin midi-program calls

  1076. 

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

  1078.     {

  1079.         if (index >= fProgramCount)

  1080.             return nullptr;

  1081. 

  1082.         static NativeMidiProgram midiProg;

  1083. 

  1084.         midiProg.bank    = 0;

  1085.         midiProg.program = index;

  1086. 

  1087.         switch (index)

  1088.         {

  1089.         case 0:

  1090.             midiProg.name = "Phaser 1";

  1091.             break;

  1092.         case 1:

  1093.             midiProg.name = "Phaser 2";

  1094.             break;

  1095.         case 2:

  1096.             midiProg.name = "Phaser 3";

  1097.             break;

  1098.         case 3:

  1099.             midiProg.name = "Phaser 4";

  1100.             break;

  1101.         case 4:

  1102.             midiProg.name = "Phaser 5";

  1103.             break;

  1104.         case 5:

  1105.             midiProg.name = "Phaser 6";

  1106.             break;

  1107.         case 6:

  1108.             midiProg.name = "APhaser 1";

  1109.             break;

  1110.         case 7:

  1111.             midiProg.name = "APhaser 2";

  1112.             break;

  1113.         case 8:

  1114.             midiProg.name = "APhaser 3";

  1115.             break;

  1116.         case 9:

  1117.             midiProg.name = "APhaser 4";

  1118.             break;

  1119.         case 10:

  1120.             midiProg.name = "APhaser 5";

  1121.             break;

  1122.         case 11:

  1123.             midiProg.name = "APhaser 6";

  1124.             break;

  1125.         default:

  1126.             midiProg.name = nullptr;

  1127.             break;

  1128.         }

  1129. 

  1130.         return &midiProg;

  1131.     }

  1132. 

  1133.     // -------------------------------------------------------------------

  1134. 

  1135.     PluginClassEND(FxPhaserPlugin)

  1136.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1137. };

  1138. 

  1139. // -----------------------------------------------------------------------

  1140. 

  1141. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1142. {

  1143. public:

  1144.     FxReverbPlugin(const NativeHostDescriptor* const host)

  1145.         : FxAbstractPlugin(host, 13, 13),

  1146.           leakDetector_FxReverbPlugin() {}

  1147. 

  1148. protected:

  1149.     // -------------------------------------------------------------------

  1150.     // Plugin parameter calls

  1151. 

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

  1153.     {

  1154.         if (index >= fParamCount)

  1155.             return nullptr;

  1156. 

  1157.         static NativeParameter param;

  1158.         static NativeParameterScalePoint scalePoints[3];

  1159. 

  1160.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1161. 

  1162.         param.name = nullptr;

  1163.         param.unit = nullptr;

  1164.         param.ranges.def       = 1.0f;

  1165.         param.ranges.min       = 0.0f;

  1166.         param.ranges.max       = 127.0f;

  1167.         param.ranges.step      = 1.0f;

  1168.         param.ranges.stepSmall = 1.0f;

  1169.         param.ranges.stepLarge = 20.0f;

  1170.         param.scalePointCount  = 0;

  1171.         param.scalePoints      = nullptr;

  1172. 

  1173.         switch (index)

  1174.         {

  1175.         case 0:

  1176.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1177.             param.name = "Time";

  1178.             param.ranges.def = 63.0f;

  1179.             break;

  1180.         case 1:

  1181.             param.name = "Delay";

  1182.             param.ranges.def = 24.0f;

  1183.             break;

  1184.         case 2:

  1185.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1186.             param.name = "Feedback";

  1187.             param.ranges.def = 0.0f;

  1188.             break;

  1189.         case 3:

  1190.             hints = 0x0;

  1191.             param.name = "bw";

  1192.             break;

  1193.         case 4:

  1194.             hints = 0x0;

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

  1196.             break;

  1197.         case 5:

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

  1199.             param.ranges.def = 85.0f;

  1200.             break;

  1201.         case 6:

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

  1203.             param.ranges.def = 5.0f;

  1204.             break;

  1205.         case 7:

  1206.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1207.             param.name = "Damp";

  1208.             param.ranges.def = 83.0f;

  1209.             param.ranges.min = 64.0f;

  1210.             break;

  1211.         case 8:

  1212.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1213.             param.name = "Type";

  1214.             param.ranges.def = 1.0f;

  1215.             param.ranges.max = 2.0f;

  1216.             param.scalePointCount = 3;

  1217.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1224.             break;

  1225.         case 9:

  1226.             param.name = "Room size";

  1227.             param.ranges.def = 64.0f;

  1228.             param.ranges.min = 1.0f;

  1229.             break;

  1230.         case 10:

  1231.             param.name = "Bandwidth";

  1232.             param.ranges.def = 20.0f;

  1233.             break;

  1234.         }

  1235. 

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

  1237. 

  1238.         return &param;

  1239.     }

  1240. 

  1241.     // -------------------------------------------------------------------

  1242.     // Plugin midi-program calls

  1243. 

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

  1245.     {

  1246.         if (index >= fProgramCount)

  1247.             return nullptr;

  1248. 

  1249.         static NativeMidiProgram midiProg;

  1250. 

  1251.         midiProg.bank    = 0;

  1252.         midiProg.program = index;

  1253. 

  1254.         switch (index)

  1255.         {

  1256.         case 0:

  1257.             midiProg.name = "Cathedral1";

  1258.             break;

  1259.         case 1:

  1260.             midiProg.name = "Cathedral2";

  1261.             break;

  1262.         case 2:

  1263.             midiProg.name = "Cathedral3";

  1264.             break;

  1265.         case 3:

  1266.             midiProg.name = "Hall1";

  1267.             break;

  1268.         case 4:

  1269.             midiProg.name = "Hall2";

  1270.             break;

  1271.         case 5:

  1272.             midiProg.name = "Room1";

  1273.             break;

  1274.         case 6:

  1275.             midiProg.name = "Room2";

  1276.             break;

  1277.         case 7:

  1278.             midiProg.name = "Basement";

  1279.             break;

  1280.         case 8:

  1281.             midiProg.name = "Tunnel";

  1282.             break;

  1283.         case 9:

  1284.             midiProg.name = "Echoed1";

  1285.             break;

  1286.         case 10:

  1287.             midiProg.name = "Echoed2";

  1288.             break;

  1289.         case 11:

  1290.             midiProg.name = "VeryLong1";

  1291.             break;

  1292.         case 12:

  1293.             midiProg.name = "VeryLong2";

  1294.             break;

  1295.         default:

  1296.             midiProg.name = nullptr;

  1297.             break;

  1298.         }

  1299. 

  1300.         return &midiProg;

  1301.     }

  1302. 

  1303.     // -------------------------------------------------------------------

  1304. 

  1305.     PluginClassEND(FxReverbPlugin)

  1306.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1307. };

  1308. 

  1309. // -----------------------------------------------------------------------

  1310. 

  1311. static const NativePluginDescriptor fxAlienWahDesc = {

  1312.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1314.                                                   |NATIVE_PLUGIN_USES_PANNING

  1315.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1316.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  1317.     /* audioIns  */ 2,

  1318.     /* audioOuts */ 2,

  1319.     /* midiIns   */ 0,

  1320.     /* midiOuts  */ 0,

  1321.     /* paramIns  */ 11-2,

  1322.     /* paramOuts */ 0,

  1323.     /* name      */ "ZynAlienWah",

  1324.     /* label     */ "zynalienwah",

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

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

  1327.     PluginDescriptorFILL(FxAlienWahPlugin)

  1328. };

  1329. 

  1330. static const NativePluginDescriptor fxChorusDesc = {

  1331.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1333.                                                   |NATIVE_PLUGIN_USES_PANNING

  1334.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1335.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  1336.     /* audioIns  */ 2,

  1337.     /* audioOuts */ 2,

  1338.     /* midiIns   */ 0,

  1339.     /* midiOuts  */ 0,

  1340.     /* paramIns  */ 12-2,

  1341.     /* paramOuts */ 0,

  1342.     /* name      */ "ZynChorus",

  1343.     /* label     */ "zynchorus",

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

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

  1346.     PluginDescriptorFILL(FxChorusPlugin)

  1347. };

  1348. 

  1349. static const NativePluginDescriptor fxDistortionDesc = {

  1350.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1352.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1353.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  1354.     /* audioIns  */ 2,

  1355.     /* audioOuts */ 2,

  1356.     /* midiIns   */ 0,

  1357.     /* midiOuts  */ 0,

  1358.     /* paramIns  */ 11-2,

  1359.     /* paramOuts */ 0,

  1360.     /* name      */ "ZynDistortion",

  1361.     /* label     */ "zyndistortion",

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

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

  1364.     PluginDescriptorFILL(FxDistortionPlugin)

  1365. };

  1366. 

  1367. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1368.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1370.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1371.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  1372.     /* audioIns  */ 2,

  1373.     /* audioOuts */ 2,

  1374.     /* midiIns   */ 0,

  1375.     /* midiOuts  */ 0,

  1376.     /* paramIns  */ 10-2,

  1377.     /* paramOuts */ 0,

  1378.     /* name      */ "ZynDynamicFilter",

  1379.     /* label     */ "zyndynamicfilter",

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

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

  1382.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1383. };

  1384. 

  1385. static const NativePluginDescriptor fxEchoDesc = {

  1386.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1388.                                                   |NATIVE_PLUGIN_USES_PANNING

  1389.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1390.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  1391.     /* audioIns  */ 2,

  1392.     /* audioOuts */ 2,

  1393.     /* midiIns   */ 0,

  1394.     /* midiOuts  */ 0,

  1395.     /* paramIns  */ 7-2,

  1396.     /* paramOuts */ 0,

  1397.     /* name      */ "ZynEcho",

  1398.     /* label     */ "zynecho",

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

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

  1401.     PluginDescriptorFILL(FxEchoPlugin)

  1402. };

  1403. 

  1404. static const NativePluginDescriptor fxPhaserDesc = {

  1405.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1407.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1408.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  1409.     /* audioIns  */ 2,

  1410.     /* audioOuts */ 2,

  1411.     /* midiIns   */ 0,

  1412.     /* midiOuts  */ 0,

  1413.     /* paramIns  */ 15-2,

  1414.     /* paramOuts */ 0,

  1415.     /* name      */ "ZynPhaser",

  1416.     /* label     */ "zynphaser",

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

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

  1419.     PluginDescriptorFILL(FxPhaserPlugin)

  1420. };

  1421. 

  1422. static const NativePluginDescriptor fxReverbDesc = {

  1423.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1425.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1426.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  1427.     /* audioIns  */ 2,

  1428.     /* audioOuts */ 2,

  1429.     /* midiIns   */ 0,

  1430.     /* midiOuts  */ 0,

  1431.     /* paramIns  */ 13-2,

  1432.     /* paramOuts */ 0,

  1433.     /* name      */ "ZynReverb",

  1434.     /* label     */ "zynreverb",

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

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

  1437.     PluginDescriptorFILL(FxReverbPlugin)

  1438. };

  1439. 

  1440. // -----------------------------------------------------------------------

  1441. 

  1442. CARLA_EXPORT

  1443. void carla_register_native_plugin_zynaddsubfx_fx();

  1444. 

  1445. CARLA_EXPORT

  1446. void carla_register_native_plugin_zynaddsubfx_fx()

  1447. {

  1448.     carla_register_native_plugin(&fxAlienWahDesc);

  1449.     carla_register_native_plugin(&fxChorusDesc);

  1450.     carla_register_native_plugin(&fxDistortionDesc);

  1451.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1452.     carla_register_native_plugin(&fxEchoDesc);

  1453.     carla_register_native_plugin(&fxPhaserDesc);

  1454.     carla_register_native_plugin(&fxReverbDesc);

  1455. }

  1456. 

  1457. // -----------------------------------------------------------------------