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.
2791 Commits
16 Branches
14GB
Tree: 34a05e97e2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '34a05e97e2'
${ noResults }
Carla/source/native-plugins/zynaddsubfx-fx.cpp

1482 lines
45KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #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. 

  29. #include "juce_audio_basics.h"

  30. using juce::FloatVectorOperations;

  31. 

  32. // -----------------------------------------------------------------------

  33. 

  34. class FxAbstractPlugin : public NativePluginClass

  35. {

  36. protected:

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

  38.         : NativePluginClass(host),

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

  40.           fProgramCount(programCount),

  41.           fEffect(nullptr),

  42.           efxoutl(nullptr),

  43.           efxoutr(nullptr),

  44.           leakDetector_FxAbstractPlugin()

  45.     {

  46.         const int bufferSize(static_cast<int>(getBufferSize()));

  47. 

  48.         efxoutl = new float[bufferSize];

  49.         efxoutr = new float[bufferSize];

  50. 

  51.         FloatVectorOperations::clear(efxoutl, bufferSize);

  52.         FloatVectorOperations::clear(efxoutr, bufferSize);

  53.     }

  54. 

  55.     ~FxAbstractPlugin() override

  56.     {

  57.         if (efxoutl != nullptr)

  58.         {

  59.             delete[] efxoutl;

  60.             efxoutl = nullptr;

  61.         }

  62. 

  63.         if (efxoutr != nullptr)

  64.         {

  65.             delete[] efxoutr;

  66.             efxoutr = nullptr;

  67.         }

  68. 

  69.         if (fEffect != nullptr)

  70.         {

  71.             delete fEffect;

  72.             fEffect = nullptr;

  73.         }

  74.     }

  75. 

  76.     // -------------------------------------------------------------------

  77.     // Plugin parameter calls

  78. 

  79.     uint32_t getParameterCount() const final

  80.     {

  81.         return fParamCount;

  82.     }

  83. 

  84.     float getParameterValue(const uint32_t index) const final

  85.     {

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

  87.     }

  88. 

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

  90.     // Plugin midi-program calls

  91. 

  92.     uint32_t getMidiProgramCount() const final

  93.     {

  94.         return fProgramCount;

  95.     }

  96. 

  97.     // -------------------------------------------------------------------

  98.     // Plugin state calls

  99. 

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

  101.     {

  102.         fEffect->changepar(static_cast<int>(index+2), static_cast<uchar>(carla_fixValue(0.0f, 127.0f, value)));

  103.     }

  104. 

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

  106.     {

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

  108. 

  109.         // reset volume and pan

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

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

  112.     }

  113. 

  114.     // -------------------------------------------------------------------

  115.     // Plugin process calls

  116. 

  117.     void activate() final

  118.     {

  119.         fEffect->cleanup();

  120.     }

  121. 

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

  123.     {

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

  125. 

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

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

  128.         else

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

  130. 

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

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

  133.         else

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

  135. 

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

  137. 

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

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

  140.     }

  141. 

  142.     // -------------------------------------------------------------------

  143.     // Plugin dispatcher

  144. 

  145.     void bufferSizeChanged(const uint32_t bufferSize) final

  146.     {

  147.         const int ibufferSize(static_cast<int>(getBufferSize()));

  148. 

  149.         delete[] efxoutl;

  150.         delete[] efxoutr;

  151.         efxoutl = new float[bufferSize];

  152.         efxoutr = new float[bufferSize];

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

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

  155. 

  156.         doReinit(getSampleRate(), bufferSize);

  157.     }

  158. 

  159.     void sampleRateChanged(const double sampleRate) final

  160.     {

  161.         doReinit(sampleRate, getBufferSize());

  162.     }

  163. 

  164.     void doReinit(const double sampleRate, const uint32_t bufferSize)

  165.     {

  166.         uchar params[fParamCount];

  167. 

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

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

  170. 

  171.         reinit(static_cast<uint>(sampleRate), static_cast<int>(bufferSize));

  172. 

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

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

  175.     }

  176. 

  177.     virtual void reinit(const uint sampleRate, const int bufferSize) = 0;

  178. 

  179.     // -------------------------------------------------------------------

  180. 

  181.     const uint32_t fParamCount;

  182.     const uint32_t fProgramCount;

  183. 

  184.     Effect* fEffect;

  185.     float*  efxoutl;

  186.     float*  efxoutr;

  187. 

  188.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  189. };

  190. 

  191. // -----------------------------------------------------------------------

  192. 

  193. class FxAlienWahPlugin : public FxAbstractPlugin

  194. {

  195. public:

  196.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

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

  198.           leakDetector_FxAlienWahPlugin()

  199.     {

  200.         fEffect = new Alienwah(false, efxoutl, efxoutr, static_cast<uint>(getSampleRate()), static_cast<int>(getBufferSize()));

  201.     }

  202. 

  203. protected:

  204.     // -------------------------------------------------------------------

  205.     // Plugin parameter calls

  206. 

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

  208.     {

  209.         if (index >= fParamCount)

  210.             return nullptr;

  211. 

  212.         static NativeParameter param;

  213.         static NativeParameterScalePoint scalePoints[2];

  214. 

  215.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  216. 

  217.         param.name = nullptr;

  218.         param.unit = nullptr;

  219.         param.ranges.def       = 1.0f;

  220.         param.ranges.min       = 0.0f;

  221.         param.ranges.max       = 127.0f;

  222.         param.ranges.step      = 1.0f;

  223.         param.ranges.stepSmall = 1.0f;

  224.         param.ranges.stepLarge = 20.0f;

  225.         param.scalePointCount  = 0;

  226.         param.scalePoints      = nullptr;

  227. 

  228.         switch (index)

  229.         {

  230.         case 0:

  231.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  232.             param.name = "LFO Frequency";

  233.             param.ranges.def = 70.0f;

  234.             break;

  235.         case 1:

  236.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  237.             param.name = "LFO Randomness";

  238.             param.ranges.def = 0.0f;

  239.             break;

  240.         case 2:

  241.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  242.             param.name = "LFO Type";

  243.             param.ranges.def = 0.0f;

  244.             param.ranges.max = 1.0f;

  245.             param.scalePointCount = 2;

  246.             param.scalePoints     = scalePoints;

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

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

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

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

  251.             break;

  252.         case 3:

  253.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  254.             param.name = "LFO Stereo";

  255.             param.ranges.def = 62.0f;

  256.             break;

  257.         case 4:

  258.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  259.             param.name = "Depth";

  260.             param.ranges.def = 60.0f;

  261.             break;

  262.         case 5:

  263.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  264.             param.name = "Feedback";

  265.             param.ranges.def = 105.0f;

  266.             break;

  267.         case 6:

  268.             param.name = "Delay";

  269.             param.ranges.def = 25.0f;

  270.             param.ranges.min = 1.0f;

  271.             param.ranges.max = 100.0f;

  272.             break;

  273.         case 7:

  274.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  276.             param.ranges.def = 0.0f;

  277.             break;

  278.         case 8:

  279.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  280.             param.name = "Phase";

  281.             param.ranges.def = 64.0f;

  282.             break;

  283.         }

  284. 

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

  286. 

  287.         return &param;

  288.     }

  289. 

  290.     // -------------------------------------------------------------------

  291.     // Plugin midi-program calls

  292. 

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

  294.     {

  295.         if (index >= fProgramCount)

  296.             return nullptr;

  297. 

  298.         static NativeMidiProgram midiProg;

  299. 

  300.         midiProg.bank    = 0;

  301.         midiProg.program = index;

  302. 

  303.         switch (index)

  304.         {

  305.         case 0:

  306.             midiProg.name = "AlienWah1";

  307.             break;

  308.         case 1:

  309.             midiProg.name = "AlienWah2";

  310.             break;

  311.         case 2:

  312.             midiProg.name = "AlienWah3";

  313.             break;

  314.         case 3:

  315.             midiProg.name = "AlienWah4";

  316.             break;

  317.         default:

  318.             midiProg.name = nullptr;

  319.             break;

  320.         }

  321. 

  322.         return &midiProg;

  323.     }

  324. 

  325.     // -------------------------------------------------------------------

  326. 

  327.     void reinit(const uint sampleRate, const int bufferSize) override

  328.     {

  329.         delete fEffect;

  330.         fEffect = new Alienwah(false, efxoutl, efxoutr, sampleRate, bufferSize);

  331.     }

  332. 

  333.     PluginClassEND(FxAlienWahPlugin)

  334.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  335. };

  336. 

  337. // -----------------------------------------------------------------------

  338. 

  339. class FxChorusPlugin : public FxAbstractPlugin

  340. {

  341. public:

  342.     FxChorusPlugin(const NativeHostDescriptor* const host)

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

  344.           leakDetector_FxChorusPlugin()

  345.     {

  346.         fEffect = new Chorus(false, efxoutl, efxoutr, static_cast<uint>(getSampleRate()), static_cast<int>(getBufferSize()));

  347.     }

  348. 

  349. protected:

  350.     // -------------------------------------------------------------------

  351.     // Plugin parameter calls

  352. 

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

  354.     {

  355.         if (index >= fParamCount)

  356.             return nullptr;

  357. 

  358.         static NativeParameter param;

  359.         static NativeParameterScalePoint scalePoints[2];

  360. 

  361.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  362. 

  363.         param.name = nullptr;

  364.         param.unit = nullptr;

  365.         param.ranges.def       = 1.0f;

  366.         param.ranges.min       = 0.0f;

  367.         param.ranges.max       = 127.0f;

  368.         param.ranges.step      = 1.0f;

  369.         param.ranges.stepSmall = 1.0f;

  370.         param.ranges.stepLarge = 20.0f;

  371.         param.scalePointCount  = 0;

  372.         param.scalePoints      = nullptr;

  373. 

  374.         switch (index)

  375.         {

  376.         case 0:

  377.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  378.             param.name = "LFO Frequency";

  379.             param.ranges.def = 50.0f;

  380.             break;

  381.         case 1:

  382.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  383.             param.name = "LFO Randomness";

  384.             param.ranges.def = 0.0f;

  385.             break;

  386.         case 2:

  387.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  388.             param.name = "LFO Type";

  389.             param.ranges.def = 0.0f;

  390.             param.ranges.max = 1.0f;

  391.             param.scalePointCount = 2;

  392.             param.scalePoints     = scalePoints;

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

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

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

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

  397.             break;

  398.         case 3:

  399.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  400.             param.name = "LFO Stereo";

  401.             param.ranges.def = 90.0f;

  402.             break;

  403.         case 4:

  404.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  405.             param.name = "Depth";

  406.             param.ranges.def = 40.0f;

  407.             break;

  408.         case 5:

  409.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  410.             param.name = "Delay";

  411.             param.ranges.def = 85.0f;

  412.             break;

  413.         case 6:

  414.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  415.             param.name = "Feedback";

  416.             param.ranges.def = 64.0f;

  417.             break;

  418.         case 7:

  419.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  421.             param.ranges.def = 119.0f;

  422.             break;

  423.         case 8:

  424.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  425.             param.name = "Flange Mode";

  426.             param.ranges.def = 0.0f;

  427.             param.ranges.max = 1.0f;

  428.             break;

  429.         case 9:

  430.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  431.             param.name = "Subtract Output";

  432.             param.ranges.def = 0.0f;

  433.             param.ranges.max = 1.0f;

  434.             break;

  435.         }

  436. 

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

  438. 

  439.         return &param;

  440.     }

  441. 

  442.     // -------------------------------------------------------------------

  443.     // Plugin midi-program calls

  444. 

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

  446.     {

  447.         if (index >= fProgramCount)

  448.             return nullptr;

  449. 

  450.         static NativeMidiProgram midiProg;

  451. 

  452.         midiProg.bank    = 0;

  453.         midiProg.program = index;

  454. 

  455.         switch (index)

  456.         {

  457.         case 0:

  458.             midiProg.name = "Chorus1";

  459.             break;

  460.         case 1:

  461.             midiProg.name = "Chorus2";

  462.             break;

  463.         case 2:

  464.             midiProg.name = "Chorus3";

  465.             break;

  466.         case 3:

  467.             midiProg.name = "Celeste1";

  468.             break;

  469.         case 4:

  470.             midiProg.name = "Celeste2";

  471.             break;

  472.         case 5:

  473.             midiProg.name = "Flange1";

  474.             break;

  475.         case 6:

  476.             midiProg.name = "Flange2";

  477.             break;

  478.         case 7:

  479.             midiProg.name = "Flange3";

  480.             break;

  481.         case 8:

  482.             midiProg.name = "Flange4";

  483.             break;

  484.         case 9:

  485.             midiProg.name = "Flange5";

  486.             break;

  487.         default:

  488.             midiProg.name = nullptr;

  489.             break;

  490.         }

  491. 

  492.         return &midiProg;

  493.     }

  494. 

  495.     // -------------------------------------------------------------------

  496. 

  497.     void reinit(const uint sampleRate, const int bufferSize) override

  498.     {

  499.         delete fEffect;

  500.         fEffect = new Chorus(false, efxoutl, efxoutr, sampleRate, bufferSize);

  501.     }

  502. 

  503.     PluginClassEND(FxChorusPlugin)

  504.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  505. };

  506. 

  507. // -----------------------------------------------------------------------

  508. 

  509. class FxDistortionPlugin : public FxAbstractPlugin

  510. {

  511. public:

  512.     FxDistortionPlugin(const NativeHostDescriptor* const host)

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

  514.           leakDetector_FxDistortionPlugin()

  515.     {

  516.         fEffect = new Distorsion(false, efxoutl, efxoutr, static_cast<uint>(getSampleRate()), static_cast<int>(getBufferSize()));

  517.     }

  518. 

  519. protected:

  520.     // -------------------------------------------------------------------

  521.     // Plugin parameter calls

  522. 

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

  524.     {

  525.         if (index >= fParamCount)

  526.             return nullptr;

  527. 

  528.         static NativeParameter param;

  529.         static NativeParameterScalePoint scalePoints[14];

  530. 

  531.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  532. 

  533.         param.name = nullptr;

  534.         param.unit = nullptr;

  535.         param.ranges.def       = 1.0f;

  536.         param.ranges.min       = 0.0f;

  537.         param.ranges.max       = 127.0f;

  538.         param.ranges.step      = 1.0f;

  539.         param.ranges.stepSmall = 1.0f;

  540.         param.ranges.stepLarge = 20.0f;

  541.         param.scalePointCount  = 0;

  542.         param.scalePoints      = nullptr;

  543. 

  544.         switch (index)

  545.         {

  546.         case 0:

  547.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  549.             param.ranges.def = 35.0f;

  550.             break;

  551.         case 1:

  552.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  553.             param.name = "Drive";

  554.             param.ranges.def = 56.0f;

  555.             break;

  556.         case 2:

  557.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  558.             param.name = "Level";

  559.             param.ranges.def = 70.0f;

  560.             break;

  561.         case 3:

  562.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  563.             param.name = "Type";

  564.             param.ranges.def = 0.0f;

  565.             param.ranges.max = 13.0f;

  566.             param.scalePointCount = 14;

  567.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  596.             break;

  597.         case 4:

  598.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  599.             param.name = "Negate";

  600.             param.ranges.def = 0.0f;

  601.             param.ranges.max = 1.0f;

  602.             break;

  603.         case 5:

  604.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  606.             param.ranges.def = 96.0f;

  607.             break;

  608.         case 6:

  609.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  611.             param.ranges.def = 0.0f;

  612.             break;

  613.         case 7:

  614.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  615.             param.name = "Stereo";

  616.             param.ranges.def = 0.0f;

  617.             param.ranges.max = 1.0f;

  618.             break;

  619.         case 8:

  620.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  622.             param.ranges.def = 0.0f;

  623.             param.ranges.max = 1.0f;

  624.             break;

  625.         }

  626. 

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

  628. 

  629.         return &param;

  630.     }

  631. 

  632.     // -------------------------------------------------------------------

  633.     // Plugin midi-program calls

  634. 

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

  636.     {

  637.         if (index >= fProgramCount)

  638.             return nullptr;

  639. 

  640.         static NativeMidiProgram midiProg;

  641. 

  642.         midiProg.bank    = 0;

  643.         midiProg.program = index;

  644. 

  645.         switch (index)

  646.         {

  647.         case 0:

  648.             midiProg.name = "Overdrive 1";

  649.             break;

  650.         case 1:

  651.             midiProg.name = "Overdrive 2";

  652.             break;

  653.         case 2:

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

  655.             break;

  656.         case 3:

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

  658.             break;

  659.         case 4:

  660.             midiProg.name = "Guitar Amp";

  661.             break;

  662.         case 5:

  663.             midiProg.name = "Quantisize";

  664.             break;

  665.         default:

  666.             midiProg.name = nullptr;

  667.             break;

  668.         }

  669. 

  670.         return &midiProg;

  671.     }

  672. 

  673.     // -------------------------------------------------------------------

  674. 

  675.     void reinit(const uint sampleRate, const int bufferSize) override

  676.     {

  677.         delete fEffect;

  678.         fEffect = new Distorsion(false, efxoutl, efxoutr, sampleRate, bufferSize);

  679.     }

  680. 

  681.     PluginClassEND(FxDistortionPlugin)

  682.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  683. };

  684. 

  685. // -----------------------------------------------------------------------

  686. 

  687. class FxDynamicFilterPlugin : public FxAbstractPlugin

  688. {

  689. public:

  690.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

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

  692.           leakDetector_FxDynamicFilterPlugin()

  693.     {

  694.         fEffect = new DynamicFilter(false, efxoutl, efxoutr, static_cast<uint>(getSampleRate()), static_cast<int>(getBufferSize()));

  695.     }

  696. 

  697. protected:

  698.     // -------------------------------------------------------------------

  699.     // Plugin parameter calls

  700. 

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

  702.     {

  703.         if (index >= fParamCount)

  704.             return nullptr;

  705. 

  706.         static NativeParameter param;

  707.         static NativeParameterScalePoint scalePoints[2];

  708. 

  709.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  710. 

  711.         param.name = nullptr;

  712.         param.unit = nullptr;

  713.         param.ranges.def       = 1.0f;

  714.         param.ranges.min       = 0.0f;

  715.         param.ranges.max       = 127.0f;

  716.         param.ranges.step      = 1.0f;

  717.         param.ranges.stepSmall = 1.0f;

  718.         param.ranges.stepLarge = 20.0f;

  719.         param.scalePointCount  = 0;

  720.         param.scalePoints      = nullptr;

  721. 

  722.         switch (index)

  723.         {

  724.         case 0:

  725.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  726.             param.name = "LFO Frequency";

  727.             param.ranges.def = 80.0f;

  728.             break;

  729.         case 1:

  730.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  731.             param.name = "LFO Randomness";

  732.             param.ranges.def = 0.0f;

  733.             break;

  734.         case 2:

  735.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  736.             param.name = "LFO Type";

  737.             param.ranges.def = 0.0f;

  738.             param.ranges.max = 1.0f;

  739.             param.scalePointCount = 2;

  740.             param.scalePoints     = scalePoints;

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

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

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

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

  745.             break;

  746.         case 3:

  747.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  748.             param.name = "LFO Stereo";

  749.             param.ranges.def = 64.0f;

  750.             break;

  751.         case 4:

  752.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  753.             param.name = "LFO Depth";

  754.             param.ranges.def = 0.0f;

  755.             break;

  756.         case 5:

  757.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  758.             param.name = "Amp sns";

  759.             param.ranges.def = 90.0f;

  760.             break;

  761.         case 6:

  762.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  764.             param.ranges.def = 0.0f;

  765.             param.ranges.max = 1.0f;

  766.             break;

  767.         case 7:

  768.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  769.             param.name = "Amp Smooth";

  770.             param.ranges.def = 60.0f;

  771.             break;

  772.         }

  773. 

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

  775. 

  776.         return &param;

  777.     }

  778. 

  779.     // -------------------------------------------------------------------

  780.     // Plugin midi-program calls

  781. 

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

  783.     {

  784.         if (index >= fProgramCount)

  785.             return nullptr;

  786. 

  787.         static NativeMidiProgram midiProg;

  788. 

  789.         midiProg.bank    = 0;

  790.         midiProg.program = index;

  791. 

  792.         switch (index)

  793.         {

  794.         case 0:

  795.             midiProg.name = "WahWah";

  796.             break;

  797.         case 1:

  798.             midiProg.name = "AutoWah";

  799.             break;

  800.         case 2:

  801.             midiProg.name = "Sweep";

  802.             break;

  803.         case 3:

  804.             midiProg.name = "VocalMorph1";

  805.             break;

  806.         case 4:

  807.             midiProg.name = "VocalMorph2";

  808.             break;

  809.         default:

  810.             midiProg.name = nullptr;

  811.             break;

  812.         }

  813. 

  814.         return &midiProg;

  815.     }

  816. 

  817.     // -------------------------------------------------------------------

  818. 

  819.     void reinit(const uint sampleRate, const int bufferSize) override

  820.     {

  821.         delete fEffect;

  822.         fEffect = new DynamicFilter(false, efxoutl, efxoutr, sampleRate, bufferSize);

  823.     }

  824. 

  825.     PluginClassEND(FxDynamicFilterPlugin)

  826.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  827. };

  828. 

  829. // -----------------------------------------------------------------------

  830. 

  831. class FxEchoPlugin : public FxAbstractPlugin

  832. {

  833. public:

  834.     FxEchoPlugin(const NativeHostDescriptor* const host)

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

  836.           leakDetector_FxEchoPlugin()

  837.     {

  838.         fEffect = new Echo(false, efxoutl, efxoutr, static_cast<uint>(getSampleRate()), static_cast<int>(getBufferSize()));

  839.     }

  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.     void reinit(const uint sampleRate, const int bufferSize) override

  952.     {

  953.         delete fEffect;

  954.         fEffect = new Echo(false, efxoutl, efxoutr, sampleRate, bufferSize);

  955.     }

  956. 

  957.     PluginClassEND(FxEchoPlugin)

  958.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  959. };

  960. 

  961. // -----------------------------------------------------------------------

  962. 

  963. class FxPhaserPlugin : public FxAbstractPlugin

  964. {

  965. public:

  966.     FxPhaserPlugin(const NativeHostDescriptor* const host)

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

  968.           leakDetector_FxPhaserPlugin()

  969.     {

  970.         fEffect = new Phaser(false, efxoutl, efxoutr, static_cast<uint>(getSampleRate()), static_cast<int>(getBufferSize()));

  971.     }

  972. 

  973. protected:

  974.     // -------------------------------------------------------------------

  975.     // Plugin parameter calls

  976. 

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

  978.     {

  979.         if (index >= fParamCount)

  980.             return nullptr;

  981. 

  982.         static NativeParameter param;

  983.         static NativeParameterScalePoint scalePoints[2];

  984. 

  985.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  986. 

  987.         param.name = nullptr;

  988.         param.unit = nullptr;

  989.         param.ranges.def       = 1.0f;

  990.         param.ranges.min       = 0.0f;

  991.         param.ranges.max       = 127.0f;

  992.         param.ranges.step      = 1.0f;

  993.         param.ranges.stepSmall = 1.0f;

  994.         param.ranges.stepLarge = 20.0f;

  995.         param.scalePointCount  = 0;

  996.         param.scalePoints      = nullptr;

  997. 

  998.         switch (index)

  999.         {

  1000.         case 0:

  1001.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1002.             param.name = "LFO Frequency";

  1003.             param.ranges.def = 36.0f;

  1004.             break;

  1005.         case 1:

  1006.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1007.             param.name = "LFO Randomness";

  1008.             param.ranges.def = 0.0f;

  1009.             break;

  1010.         case 2:

  1011.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1012.             param.name = "LFO Type";

  1013.             param.ranges.def = 0.0f;

  1014.             param.ranges.max = 1.0f;

  1015.             param.scalePointCount = 2;

  1016.             param.scalePoints     = scalePoints;

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

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

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

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

  1021.             break;

  1022.         case 3:

  1023.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1024.             param.name = "LFO Stereo";

  1025.             param.ranges.def = 64.0f;

  1026.             break;

  1027.         case 4:

  1028.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1029.             param.name = "Depth";

  1030.             param.ranges.def = 110.0f;

  1031.             break;

  1032.         case 5:

  1033.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1034.             param.name = "Feedback";

  1035.             param.ranges.def = 64.0f;

  1036.             break;

  1037.         case 6:

  1038.             param.name = "Stages";

  1039.             param.ranges.def = 1.0f;

  1040.             param.ranges.min = 1.0f;

  1041.             param.ranges.max = 12.0f;

  1042.             break;

  1043.         case 7:

  1044.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1046.             param.ranges.def = 0.0f;

  1047.             break;

  1048.         case 8:

  1049.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1050.             param.name = "Subtract Output";

  1051.             param.ranges.def = 0.0f;

  1052.             param.ranges.max = 1.0f;

  1053.             break;

  1054.         case 9:

  1055.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1057.             param.ranges.def = 20.0f;

  1058.             break;

  1059.         case 10:

  1060.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1061.             param.name = "Hyper";

  1062.             param.ranges.def = 0.0f;

  1063.             param.ranges.max = 1.0f;

  1064.             break;

  1065.         case 11:

  1066.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1067.             param.name = "Distortion";

  1068.             param.ranges.def = 0.0f;

  1069.             break;

  1070.         case 12:

  1071.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1072.             param.name = "Analog";

  1073.             param.ranges.def = 0.0f;

  1074.             param.ranges.max = 1.0f;

  1075.             break;

  1076.         }

  1077. 

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

  1079. 

  1080.         return &param;

  1081.     }

  1082. 

  1083.     // -------------------------------------------------------------------

  1084.     // Plugin midi-program calls

  1085. 

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

  1087.     {

  1088.         if (index >= fProgramCount)

  1089.             return nullptr;

  1090. 

  1091.         static NativeMidiProgram midiProg;

  1092. 

  1093.         midiProg.bank    = 0;

  1094.         midiProg.program = index;

  1095. 

  1096.         switch (index)

  1097.         {

  1098.         case 0:

  1099.             midiProg.name = "Phaser 1";

  1100.             break;

  1101.         case 1:

  1102.             midiProg.name = "Phaser 2";

  1103.             break;

  1104.         case 2:

  1105.             midiProg.name = "Phaser 3";

  1106.             break;

  1107.         case 3:

  1108.             midiProg.name = "Phaser 4";

  1109.             break;

  1110.         case 4:

  1111.             midiProg.name = "Phaser 5";

  1112.             break;

  1113.         case 5:

  1114.             midiProg.name = "Phaser 6";

  1115.             break;

  1116.         case 6:

  1117.             midiProg.name = "APhaser 1";

  1118.             break;

  1119.         case 7:

  1120.             midiProg.name = "APhaser 2";

  1121.             break;

  1122.         case 8:

  1123.             midiProg.name = "APhaser 3";

  1124.             break;

  1125.         case 9:

  1126.             midiProg.name = "APhaser 4";

  1127.             break;

  1128.         case 10:

  1129.             midiProg.name = "APhaser 5";

  1130.             break;

  1131.         case 11:

  1132.             midiProg.name = "APhaser 6";

  1133.             break;

  1134.         default:

  1135.             midiProg.name = nullptr;

  1136.             break;

  1137.         }

  1138. 

  1139.         return &midiProg;

  1140.     }

  1141. 

  1142.     // -------------------------------------------------------------------

  1143. 

  1144.     void reinit(const uint sampleRate, const int bufferSize) override

  1145.     {

  1146.         delete fEffect;

  1147.         fEffect = new Phaser(false, efxoutl, efxoutr, sampleRate, bufferSize);

  1148.     }

  1149. 

  1150.     PluginClassEND(FxPhaserPlugin)

  1151.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1152. };

  1153. 

  1154. // -----------------------------------------------------------------------

  1155. 

  1156. class FxReverbPlugin : public FxAbstractPlugin

  1157. {

  1158. public:

  1159.     FxReverbPlugin(const NativeHostDescriptor* const host)

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

  1161.           leakDetector_FxReverbPlugin()

  1162.     {

  1163.         fEffect = new Reverb(false, efxoutl, efxoutr, static_cast<uint>(getSampleRate()), static_cast<int>(getBufferSize()));

  1164.     }

  1165. 

  1166. protected:

  1167.     // -------------------------------------------------------------------

  1168.     // Plugin parameter calls

  1169. 

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

  1171.     {

  1172.         if (index >= fParamCount)

  1173.             return nullptr;

  1174. 

  1175.         static NativeParameter param;

  1176.         static NativeParameterScalePoint scalePoints[3];

  1177. 

  1178.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1179. 

  1180.         param.name = nullptr;

  1181.         param.unit = nullptr;

  1182.         param.ranges.def       = 1.0f;

  1183.         param.ranges.min       = 0.0f;

  1184.         param.ranges.max       = 127.0f;

  1185.         param.ranges.step      = 1.0f;

  1186.         param.ranges.stepSmall = 1.0f;

  1187.         param.ranges.stepLarge = 20.0f;

  1188.         param.scalePointCount  = 0;

  1189.         param.scalePoints      = nullptr;

  1190. 

  1191.         switch (index)

  1192.         {

  1193.         case 0:

  1194.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1195.             param.name = "Time";

  1196.             param.ranges.def = 63.0f;

  1197.             break;

  1198.         case 1:

  1199.             param.name = "Delay";

  1200.             param.ranges.def = 24.0f;

  1201.             break;

  1202.         case 2:

  1203.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1204.             param.name = "Feedback";

  1205.             param.ranges.def = 0.0f;

  1206.             break;

  1207.         case 3:

  1208.             hints = 0x0;

  1209.             param.name = "bw";

  1210.             break;

  1211.         case 4:

  1212.             hints = 0x0;

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

  1214.             break;

  1215.         case 5:

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

  1217.             param.ranges.def = 85.0f;

  1218.             break;

  1219.         case 6:

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

  1221.             param.ranges.def = 5.0f;

  1222.             break;

  1223.         case 7:

  1224.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1225.             param.name = "Damp";

  1226.             param.ranges.def = 83.0f;

  1227.             param.ranges.min = 64.0f;

  1228.             break;

  1229.         case 8:

  1230.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1231.             param.name = "Type";

  1232.             param.ranges.def = 1.0f;

  1233.             param.ranges.max = 2.0f;

  1234.             param.scalePointCount = 3;

  1235.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1242.             break;

  1243.         case 9:

  1244.             param.name = "Room size";

  1245.             param.ranges.def = 64.0f;

  1246.             param.ranges.min = 1.0f;

  1247.             break;

  1248.         case 10:

  1249.             param.name = "Bandwidth";

  1250.             param.ranges.def = 20.0f;

  1251.             break;

  1252.         }

  1253. 

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

  1255. 

  1256.         return &param;

  1257.     }

  1258. 

  1259.     // -------------------------------------------------------------------

  1260.     // Plugin midi-program calls

  1261. 

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

  1263.     {

  1264.         if (index >= fProgramCount)

  1265.             return nullptr;

  1266. 

  1267.         static NativeMidiProgram midiProg;

  1268. 

  1269.         midiProg.bank    = 0;

  1270.         midiProg.program = index;

  1271. 

  1272.         switch (index)

  1273.         {

  1274.         case 0:

  1275.             midiProg.name = "Cathedral1";

  1276.             break;

  1277.         case 1:

  1278.             midiProg.name = "Cathedral2";

  1279.             break;

  1280.         case 2:

  1281.             midiProg.name = "Cathedral3";

  1282.             break;

  1283.         case 3:

  1284.             midiProg.name = "Hall1";

  1285.             break;

  1286.         case 4:

  1287.             midiProg.name = "Hall2";

  1288.             break;

  1289.         case 5:

  1290.             midiProg.name = "Room1";

  1291.             break;

  1292.         case 6:

  1293.             midiProg.name = "Room2";

  1294.             break;

  1295.         case 7:

  1296.             midiProg.name = "Basement";

  1297.             break;

  1298.         case 8:

  1299.             midiProg.name = "Tunnel";

  1300.             break;

  1301.         case 9:

  1302.             midiProg.name = "Echoed1";

  1303.             break;

  1304.         case 10:

  1305.             midiProg.name = "Echoed2";

  1306.             break;

  1307.         case 11:

  1308.             midiProg.name = "VeryLong1";

  1309.             break;

  1310.         case 12:

  1311.             midiProg.name = "VeryLong2";

  1312.             break;

  1313.         default:

  1314.             midiProg.name = nullptr;

  1315.             break;

  1316.         }

  1317. 

  1318.         return &midiProg;

  1319.     }

  1320. 

  1321.     // -------------------------------------------------------------------

  1322. 

  1323.     void reinit(const uint sampleRate, const int bufferSize) override

  1324.     {

  1325.         delete fEffect;

  1326.         fEffect = new Reverb(false, efxoutl, efxoutr, sampleRate, bufferSize);

  1327.     }

  1328. 

  1329.     PluginClassEND(FxReverbPlugin)

  1330.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1331. };

  1332. 

  1333. // -----------------------------------------------------------------------

  1334. 

  1335. static const NativePluginDescriptor fxAlienWahDesc = {

  1336.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1338.                                                   |NATIVE_PLUGIN_USES_PANNING

  1339.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1341.     /* audioIns  */ 2,

  1342.     /* audioOuts */ 2,

  1343.     /* midiIns   */ 0,

  1344.     /* midiOuts  */ 0,

  1345.     /* paramIns  */ 11-2,

  1346.     /* paramOuts */ 0,

  1347.     /* name      */ "ZynAlienWah",

  1348.     /* label     */ "zynalienwah",

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

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

  1351.     PluginDescriptorFILL(FxAlienWahPlugin)

  1352. };

  1353. 

  1354. static const NativePluginDescriptor fxChorusDesc = {

  1355.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1357.                                                   |NATIVE_PLUGIN_USES_PANNING

  1358.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1360.     /* audioIns  */ 2,

  1361.     /* audioOuts */ 2,

  1362.     /* midiIns   */ 0,

  1363.     /* midiOuts  */ 0,

  1364.     /* paramIns  */ 12-2,

  1365.     /* paramOuts */ 0,

  1366.     /* name      */ "ZynChorus",

  1367.     /* label     */ "zynchorus",

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

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

  1370.     PluginDescriptorFILL(FxChorusPlugin)

  1371. };

  1372. 

  1373. static const NativePluginDescriptor fxDistortionDesc = {

  1374.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1376.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1378.     /* audioIns  */ 2,

  1379.     /* audioOuts */ 2,

  1380.     /* midiIns   */ 0,

  1381.     /* midiOuts  */ 0,

  1382.     /* paramIns  */ 11-2,

  1383.     /* paramOuts */ 0,

  1384.     /* name      */ "ZynDistortion",

  1385.     /* label     */ "zyndistortion",

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

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

  1388.     PluginDescriptorFILL(FxDistortionPlugin)

  1389. };

  1390. 

  1391. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1392.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1394.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1396.     /* audioIns  */ 2,

  1397.     /* audioOuts */ 2,

  1398.     /* midiIns   */ 0,

  1399.     /* midiOuts  */ 0,

  1400.     /* paramIns  */ 10-2,

  1401.     /* paramOuts */ 0,

  1402.     /* name      */ "ZynDynamicFilter",

  1403.     /* label     */ "zyndynamicfilter",

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

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

  1406.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1407. };

  1408. 

  1409. static const NativePluginDescriptor fxEchoDesc = {

  1410.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1412.                                                   |NATIVE_PLUGIN_USES_PANNING

  1413.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1415.     /* audioIns  */ 2,

  1416.     /* audioOuts */ 2,

  1417.     /* midiIns   */ 0,

  1418.     /* midiOuts  */ 0,

  1419.     /* paramIns  */ 7-2,

  1420.     /* paramOuts */ 0,

  1421.     /* name      */ "ZynEcho",

  1422.     /* label     */ "zynecho",

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

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

  1425.     PluginDescriptorFILL(FxEchoPlugin)

  1426. };

  1427. 

  1428. static const NativePluginDescriptor fxPhaserDesc = {

  1429.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1431.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1433.     /* audioIns  */ 2,

  1434.     /* audioOuts */ 2,

  1435.     /* midiIns   */ 0,

  1436.     /* midiOuts  */ 0,

  1437.     /* paramIns  */ 15-2,

  1438.     /* paramOuts */ 0,

  1439.     /* name      */ "ZynPhaser",

  1440.     /* label     */ "zynphaser",

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

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

  1443.     PluginDescriptorFILL(FxPhaserPlugin)

  1444. };

  1445. 

  1446. static const NativePluginDescriptor fxReverbDesc = {

  1447.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1449.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1451.     /* audioIns  */ 2,

  1452.     /* audioOuts */ 2,

  1453.     /* midiIns   */ 0,

  1454.     /* midiOuts  */ 0,

  1455.     /* paramIns  */ 13-2,

  1456.     /* paramOuts */ 0,

  1457.     /* name      */ "ZynReverb",

  1458.     /* label     */ "zynreverb",

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

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

  1461.     PluginDescriptorFILL(FxReverbPlugin)

  1462. };

  1463. 

  1464. // -----------------------------------------------------------------------

  1465. 

  1466. CARLA_EXPORT

  1467. void carla_register_native_plugin_zynaddsubfx_fx();

  1468. 

  1469. CARLA_EXPORT

  1470. void carla_register_native_plugin_zynaddsubfx_fx()

  1471. {

  1472.     carla_register_native_plugin(&fxAlienWahDesc);

  1473.     carla_register_native_plugin(&fxChorusDesc);

  1474.     carla_register_native_plugin(&fxDistortionDesc);

  1475.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1476.     carla_register_native_plugin(&fxEchoDesc);

  1477.     carla_register_native_plugin(&fxPhaserDesc);

  1478.     carla_register_native_plugin(&fxReverbDesc);

  1479. }

  1480. 

  1481. // -----------------------------------------------------------------------