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.
2918 Commits
16 Branches
190MB
Tree: 9a5cc80fed
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9a5cc80fed'
${ noResults }
Carla/source/native-plugins/zynaddsubfx-fx.cpp

1485 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::roundToIntAccurate;

  31. using juce::FloatVectorOperations;

  32. 

  33. // -----------------------------------------------------------------------

  34. 

  35. class FxAbstractPlugin : public NativePluginClass

  36. {

  37. protected:

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

  39.         : NativePluginClass(host),

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

  41.           fProgramCount(programCount),

  42.           fEffect(nullptr),

  43.           efxoutl(nullptr),

  44.           efxoutr(nullptr),

  45.           leakDetector_FxAbstractPlugin()

  46.     {

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

  48. 

  49.         efxoutl = new float[bufferSize];

  50.         efxoutr = new float[bufferSize];

  51. 

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

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

  54.     }

  55. 

  56.     ~FxAbstractPlugin() override

  57.     {

  58.         if (efxoutl != nullptr)

  59.         {

  60.             delete[] efxoutl;

  61.             efxoutl = nullptr;

  62.         }

  63. 

  64.         if (efxoutr != nullptr)

  65.         {

  66.             delete[] efxoutr;

  67.             efxoutr = nullptr;

  68.         }

  69. 

  70.         if (fEffect != nullptr)

  71.         {

  72.             delete fEffect;

  73.             fEffect = nullptr;

  74.         }

  75.     }

  76. 

  77.     // -------------------------------------------------------------------

  78.     // Plugin parameter calls

  79. 

  80.     uint32_t getParameterCount() const final

  81.     {

  82.         return fParamCount;

  83.     }

  84. 

  85.     float getParameterValue(const uint32_t index) const final

  86.     {

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

  88.     }

  89. 

  90.     // -------------------------------------------------------------------

  91.     // Plugin midi-program calls

  92. 

  93.     uint32_t getMidiProgramCount() const final

  94.     {

  95.         return fProgramCount;

  96.     }

  97. 

  98.     // -------------------------------------------------------------------

  99.     // Plugin state calls

  100. 

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

  102.     {

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

  104. 

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

  106.     }

  107. 

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

  109.     {

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

  111. 

  112.         // reset volume and pan

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

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

  115.     }

  116. 

  117.     // -------------------------------------------------------------------

  118.     // Plugin process calls

  119. 

  120.     void activate() final

  121.     {

  122.         fEffect->cleanup();

  123.     }

  124. 

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

  126.     {

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

  128. 

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

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

  131.         else

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

  133. 

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

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

  136.         else

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

  138. 

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

  140. 

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

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

  143.     }

  144. 

  145.     // -------------------------------------------------------------------

  146.     // Plugin dispatcher

  147. 

  148.     void bufferSizeChanged(const uint32_t bufferSize) final

  149.     {

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

  151. 

  152.         delete[] efxoutl;

  153.         delete[] efxoutr;

  154.         efxoutl = new float[bufferSize];

  155.         efxoutr = new float[bufferSize];

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

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

  158. 

  159.         doReinit(getSampleRate(), bufferSize);

  160.     }

  161. 

  162.     void sampleRateChanged(const double sampleRate) final

  163.     {

  164.         doReinit(sampleRate, getBufferSize());

  165.     }

  166. 

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

  168.     {

  169.         uchar params[fParamCount];

  170. 

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

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

  173. 

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

  175. 

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

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

  178.     }

  179. 

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

  181. 

  182.     // -------------------------------------------------------------------

  183. 

  184.     const uint32_t fParamCount;

  185.     const uint32_t fProgramCount;

  186. 

  187.     Effect* fEffect;

  188.     float*  efxoutl;

  189.     float*  efxoutr;

  190. 

  191.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  192. };

  193. 

  194. // -----------------------------------------------------------------------

  195. 

  196. class FxAlienWahPlugin : public FxAbstractPlugin

  197. {

  198. public:

  199.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

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

  201.           leakDetector_FxAlienWahPlugin()

  202.     {

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

  204.     }

  205. 

  206. protected:

  207.     // -------------------------------------------------------------------

  208.     // Plugin parameter calls

  209. 

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

  211.     {

  212.         if (index >= fParamCount)

  213.             return nullptr;

  214. 

  215.         static NativeParameter param;

  216.         static NativeParameterScalePoint scalePoints[2];

  217. 

  218.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  219. 

  220.         param.name = nullptr;

  221.         param.unit = nullptr;

  222.         param.ranges.def       = 1.0f;

  223.         param.ranges.min       = 0.0f;

  224.         param.ranges.max       = 127.0f;

  225.         param.ranges.step      = 1.0f;

  226.         param.ranges.stepSmall = 1.0f;

  227.         param.ranges.stepLarge = 20.0f;

  228.         param.scalePointCount  = 0;

  229.         param.scalePoints      = nullptr;

  230. 

  231.         switch (index)

  232.         {

  233.         case 0:

  234.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  235.             param.name = "LFO Frequency";

  236.             param.ranges.def = 70.0f;

  237.             break;

  238.         case 1:

  239.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  240.             param.name = "LFO Randomness";

  241.             param.ranges.def = 0.0f;

  242.             break;

  243.         case 2:

  244.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  245.             param.name = "LFO Type";

  246.             param.ranges.def = 0.0f;

  247.             param.ranges.max = 1.0f;

  248.             param.scalePointCount = 2;

  249.             param.scalePoints     = scalePoints;

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

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

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

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

  254.             break;

  255.         case 3:

  256.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  257.             param.name = "LFO Stereo";

  258.             param.ranges.def = 62.0f;

  259.             break;

  260.         case 4:

  261.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  262.             param.name = "Depth";

  263.             param.ranges.def = 60.0f;

  264.             break;

  265.         case 5:

  266.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  267.             param.name = "Feedback";

  268.             param.ranges.def = 105.0f;

  269.             break;

  270.         case 6:

  271.             param.name = "Delay";

  272.             param.ranges.def = 25.0f;

  273.             param.ranges.min = 1.0f;

  274.             param.ranges.max = 100.0f;

  275.             break;

  276.         case 7:

  277.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  279.             param.ranges.def = 0.0f;

  280.             break;

  281.         case 8:

  282.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  283.             param.name = "Phase";

  284.             param.ranges.def = 64.0f;

  285.             break;

  286.         }

  287. 

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

  289. 

  290.         return &param;

  291.     }

  292. 

  293.     // -------------------------------------------------------------------

  294.     // Plugin midi-program calls

  295. 

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

  297.     {

  298.         if (index >= fProgramCount)

  299.             return nullptr;

  300. 

  301.         static NativeMidiProgram midiProg;

  302. 

  303.         midiProg.bank    = 0;

  304.         midiProg.program = index;

  305. 

  306.         switch (index)

  307.         {

  308.         case 0:

  309.             midiProg.name = "AlienWah1";

  310.             break;

  311.         case 1:

  312.             midiProg.name = "AlienWah2";

  313.             break;

  314.         case 2:

  315.             midiProg.name = "AlienWah3";

  316.             break;

  317.         case 3:

  318.             midiProg.name = "AlienWah4";

  319.             break;

  320.         default:

  321.             midiProg.name = nullptr;

  322.             break;

  323.         }

  324. 

  325.         return &midiProg;

  326.     }

  327. 

  328.     // -------------------------------------------------------------------

  329. 

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

  331.     {

  332.         delete fEffect;

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

  334.     }

  335. 

  336.     PluginClassEND(FxAlienWahPlugin)

  337.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  338. };

  339. 

  340. // -----------------------------------------------------------------------

  341. 

  342. class FxChorusPlugin : public FxAbstractPlugin

  343. {

  344. public:

  345.     FxChorusPlugin(const NativeHostDescriptor* const host)

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

  347.           leakDetector_FxChorusPlugin()

  348.     {

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

  350.     }

  351. 

  352. protected:

  353.     // -------------------------------------------------------------------

  354.     // Plugin parameter calls

  355. 

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

  357.     {

  358.         if (index >= fParamCount)

  359.             return nullptr;

  360. 

  361.         static NativeParameter param;

  362.         static NativeParameterScalePoint scalePoints[2];

  363. 

  364.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  365. 

  366.         param.name = nullptr;

  367.         param.unit = nullptr;

  368.         param.ranges.def       = 1.0f;

  369.         param.ranges.min       = 0.0f;

  370.         param.ranges.max       = 127.0f;

  371.         param.ranges.step      = 1.0f;

  372.         param.ranges.stepSmall = 1.0f;

  373.         param.ranges.stepLarge = 20.0f;

  374.         param.scalePointCount  = 0;

  375.         param.scalePoints      = nullptr;

  376. 

  377.         switch (index)

  378.         {

  379.         case 0:

  380.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  381.             param.name = "LFO Frequency";

  382.             param.ranges.def = 50.0f;

  383.             break;

  384.         case 1:

  385.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  386.             param.name = "LFO Randomness";

  387.             param.ranges.def = 0.0f;

  388.             break;

  389.         case 2:

  390.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  391.             param.name = "LFO Type";

  392.             param.ranges.def = 0.0f;

  393.             param.ranges.max = 1.0f;

  394.             param.scalePointCount = 2;

  395.             param.scalePoints     = scalePoints;

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

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

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

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

  400.             break;

  401.         case 3:

  402.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  403.             param.name = "LFO Stereo";

  404.             param.ranges.def = 90.0f;

  405.             break;

  406.         case 4:

  407.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  408.             param.name = "Depth";

  409.             param.ranges.def = 40.0f;

  410.             break;

  411.         case 5:

  412.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  413.             param.name = "Delay";

  414.             param.ranges.def = 85.0f;

  415.             break;

  416.         case 6:

  417.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  418.             param.name = "Feedback";

  419.             param.ranges.def = 64.0f;

  420.             break;

  421.         case 7:

  422.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  424.             param.ranges.def = 119.0f;

  425.             break;

  426.         case 8:

  427.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  428.             param.name = "Flange Mode";

  429.             param.ranges.def = 0.0f;

  430.             param.ranges.max = 1.0f;

  431.             break;

  432.         case 9:

  433.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  434.             param.name = "Subtract Output";

  435.             param.ranges.def = 0.0f;

  436.             param.ranges.max = 1.0f;

  437.             break;

  438.         }

  439. 

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

  441. 

  442.         return &param;

  443.     }

  444. 

  445.     // -------------------------------------------------------------------

  446.     // Plugin midi-program calls

  447. 

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

  449.     {

  450.         if (index >= fProgramCount)

  451.             return nullptr;

  452. 

  453.         static NativeMidiProgram midiProg;

  454. 

  455.         midiProg.bank    = 0;

  456.         midiProg.program = index;

  457. 

  458.         switch (index)

  459.         {

  460.         case 0:

  461.             midiProg.name = "Chorus1";

  462.             break;

  463.         case 1:

  464.             midiProg.name = "Chorus2";

  465.             break;

  466.         case 2:

  467.             midiProg.name = "Chorus3";

  468.             break;

  469.         case 3:

  470.             midiProg.name = "Celeste1";

  471.             break;

  472.         case 4:

  473.             midiProg.name = "Celeste2";

  474.             break;

  475.         case 5:

  476.             midiProg.name = "Flange1";

  477.             break;

  478.         case 6:

  479.             midiProg.name = "Flange2";

  480.             break;

  481.         case 7:

  482.             midiProg.name = "Flange3";

  483.             break;

  484.         case 8:

  485.             midiProg.name = "Flange4";

  486.             break;

  487.         case 9:

  488.             midiProg.name = "Flange5";

  489.             break;

  490.         default:

  491.             midiProg.name = nullptr;

  492.             break;

  493.         }

  494. 

  495.         return &midiProg;

  496.     }

  497. 

  498.     // -------------------------------------------------------------------

  499. 

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

  501.     {

  502.         delete fEffect;

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

  504.     }

  505. 

  506.     PluginClassEND(FxChorusPlugin)

  507.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  508. };

  509. 

  510. // -----------------------------------------------------------------------

  511. 

  512. class FxDistortionPlugin : public FxAbstractPlugin

  513. {

  514. public:

  515.     FxDistortionPlugin(const NativeHostDescriptor* const host)

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

  517.           leakDetector_FxDistortionPlugin()

  518.     {

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

  520.     }

  521. 

  522. protected:

  523.     // -------------------------------------------------------------------

  524.     // Plugin parameter calls

  525. 

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

  527.     {

  528.         if (index >= fParamCount)

  529.             return nullptr;

  530. 

  531.         static NativeParameter param;

  532.         static NativeParameterScalePoint scalePoints[14];

  533. 

  534.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  535. 

  536.         param.name = nullptr;

  537.         param.unit = nullptr;

  538.         param.ranges.def       = 1.0f;

  539.         param.ranges.min       = 0.0f;

  540.         param.ranges.max       = 127.0f;

  541.         param.ranges.step      = 1.0f;

  542.         param.ranges.stepSmall = 1.0f;

  543.         param.ranges.stepLarge = 20.0f;

  544.         param.scalePointCount  = 0;

  545.         param.scalePoints      = nullptr;

  546. 

  547.         switch (index)

  548.         {

  549.         case 0:

  550.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  552.             param.ranges.def = 35.0f;

  553.             break;

  554.         case 1:

  555.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  556.             param.name = "Drive";

  557.             param.ranges.def = 56.0f;

  558.             break;

  559.         case 2:

  560.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  561.             param.name = "Level";

  562.             param.ranges.def = 70.0f;

  563.             break;

  564.         case 3:

  565.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  566.             param.name = "Type";

  567.             param.ranges.def = 0.0f;

  568.             param.ranges.max = 13.0f;

  569.             param.scalePointCount = 14;

  570.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  599.             break;

  600.         case 4:

  601.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  602.             param.name = "Negate";

  603.             param.ranges.def = 0.0f;

  604.             param.ranges.max = 1.0f;

  605.             break;

  606.         case 5:

  607.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  609.             param.ranges.def = 96.0f;

  610.             break;

  611.         case 6:

  612.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  614.             param.ranges.def = 0.0f;

  615.             break;

  616.         case 7:

  617.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  618.             param.name = "Stereo";

  619.             param.ranges.def = 0.0f;

  620.             param.ranges.max = 1.0f;

  621.             break;

  622.         case 8:

  623.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  625.             param.ranges.def = 0.0f;

  626.             param.ranges.max = 1.0f;

  627.             break;

  628.         }

  629. 

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

  631. 

  632.         return &param;

  633.     }

  634. 

  635.     // -------------------------------------------------------------------

  636.     // Plugin midi-program calls

  637. 

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

  639.     {

  640.         if (index >= fProgramCount)

  641.             return nullptr;

  642. 

  643.         static NativeMidiProgram midiProg;

  644. 

  645.         midiProg.bank    = 0;

  646.         midiProg.program = index;

  647. 

  648.         switch (index)

  649.         {

  650.         case 0:

  651.             midiProg.name = "Overdrive 1";

  652.             break;

  653.         case 1:

  654.             midiProg.name = "Overdrive 2";

  655.             break;

  656.         case 2:

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

  658.             break;

  659.         case 3:

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

  661.             break;

  662.         case 4:

  663.             midiProg.name = "Guitar Amp";

  664.             break;

  665.         case 5:

  666.             midiProg.name = "Quantisize";

  667.             break;

  668.         default:

  669.             midiProg.name = nullptr;

  670.             break;

  671.         }

  672. 

  673.         return &midiProg;

  674.     }

  675. 

  676.     // -------------------------------------------------------------------

  677. 

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

  679.     {

  680.         delete fEffect;

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

  682.     }

  683. 

  684.     PluginClassEND(FxDistortionPlugin)

  685.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  686. };

  687. 

  688. // -----------------------------------------------------------------------

  689. 

  690. class FxDynamicFilterPlugin : public FxAbstractPlugin

  691. {

  692. public:

  693.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

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

  695.           leakDetector_FxDynamicFilterPlugin()

  696.     {

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

  698.     }

  699. 

  700. protected:

  701.     // -------------------------------------------------------------------

  702.     // Plugin parameter calls

  703. 

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

  705.     {

  706.         if (index >= fParamCount)

  707.             return nullptr;

  708. 

  709.         static NativeParameter param;

  710.         static NativeParameterScalePoint scalePoints[2];

  711. 

  712.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  713. 

  714.         param.name = nullptr;

  715.         param.unit = nullptr;

  716.         param.ranges.def       = 1.0f;

  717.         param.ranges.min       = 0.0f;

  718.         param.ranges.max       = 127.0f;

  719.         param.ranges.step      = 1.0f;

  720.         param.ranges.stepSmall = 1.0f;

  721.         param.ranges.stepLarge = 20.0f;

  722.         param.scalePointCount  = 0;

  723.         param.scalePoints      = nullptr;

  724. 

  725.         switch (index)

  726.         {

  727.         case 0:

  728.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  729.             param.name = "LFO Frequency";

  730.             param.ranges.def = 80.0f;

  731.             break;

  732.         case 1:

  733.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  734.             param.name = "LFO Randomness";

  735.             param.ranges.def = 0.0f;

  736.             break;

  737.         case 2:

  738.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  739.             param.name = "LFO Type";

  740.             param.ranges.def = 0.0f;

  741.             param.ranges.max = 1.0f;

  742.             param.scalePointCount = 2;

  743.             param.scalePoints     = scalePoints;

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

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

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

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

  748.             break;

  749.         case 3:

  750.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  751.             param.name = "LFO Stereo";

  752.             param.ranges.def = 64.0f;

  753.             break;

  754.         case 4:

  755.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  756.             param.name = "LFO Depth";

  757.             param.ranges.def = 0.0f;

  758.             break;

  759.         case 5:

  760.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  761.             param.name = "Amp sns";

  762.             param.ranges.def = 90.0f;

  763.             break;

  764.         case 6:

  765.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  767.             param.ranges.def = 0.0f;

  768.             param.ranges.max = 1.0f;

  769.             break;

  770.         case 7:

  771.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  772.             param.name = "Amp Smooth";

  773.             param.ranges.def = 60.0f;

  774.             break;

  775.         }

  776. 

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

  778. 

  779.         return &param;

  780.     }

  781. 

  782.     // -------------------------------------------------------------------

  783.     // Plugin midi-program calls

  784. 

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

  786.     {

  787.         if (index >= fProgramCount)

  788.             return nullptr;

  789. 

  790.         static NativeMidiProgram midiProg;

  791. 

  792.         midiProg.bank    = 0;

  793.         midiProg.program = index;

  794. 

  795.         switch (index)

  796.         {

  797.         case 0:

  798.             midiProg.name = "WahWah";

  799.             break;

  800.         case 1:

  801.             midiProg.name = "AutoWah";

  802.             break;

  803.         case 2:

  804.             midiProg.name = "Sweep";

  805.             break;

  806.         case 3:

  807.             midiProg.name = "VocalMorph1";

  808.             break;

  809.         case 4:

  810.             midiProg.name = "VocalMorph2";

  811.             break;

  812.         default:

  813.             midiProg.name = nullptr;

  814.             break;

  815.         }

  816. 

  817.         return &midiProg;

  818.     }

  819. 

  820.     // -------------------------------------------------------------------

  821. 

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

  823.     {

  824.         delete fEffect;

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

  826.     }

  827. 

  828.     PluginClassEND(FxDynamicFilterPlugin)

  829.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  830. };

  831. 

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

  833. 

  834. class FxEchoPlugin : public FxAbstractPlugin

  835. {

  836. public:

  837.     FxEchoPlugin(const NativeHostDescriptor* const host)

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

  839.           leakDetector_FxEchoPlugin()

  840.     {

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

  842.     }

  843. 

  844. protected:

  845.     // -------------------------------------------------------------------

  846.     // Plugin parameter calls

  847. 

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

  849.     {

  850.         if (index >= fParamCount)

  851.             return nullptr;

  852. 

  853.         static NativeParameter param;

  854. 

  855.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  856. 

  857.         param.name = nullptr;

  858.         param.unit = nullptr;

  859.         param.ranges.def       = 1.0f;

  860.         param.ranges.min       = 0.0f;

  861.         param.ranges.max       = 127.0f;

  862.         param.ranges.step      = 1.0f;

  863.         param.ranges.stepSmall = 1.0f;

  864.         param.ranges.stepLarge = 20.0f;

  865.         param.scalePointCount  = 0;

  866.         param.scalePoints      = nullptr;

  867. 

  868.         switch (index)

  869.         {

  870.         case 0:

  871.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  872.             param.name = "Delay";

  873.             param.ranges.def = 35.0f;

  874.             break;

  875.         case 1:

  876.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  878.             param.ranges.def = 64.0f;

  879.             break;

  880.         case 2:

  881.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  883.             param.ranges.def = 30.0f;

  884.             break;

  885.         case 3:

  886.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  887.             param.name = "Feedback";

  888.             param.ranges.def = 59.0f;

  889.             break;

  890.         case 4:

  891.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  892.             param.name = "High Damp";

  893.             param.ranges.def = 0.0f;

  894.             break;

  895.         }

  896. 

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

  898. 

  899.         return &param;

  900.     }

  901. 

  902.     // -------------------------------------------------------------------

  903.     // Plugin midi-program calls

  904. 

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

  906.     {

  907.         if (index >= fProgramCount)

  908.             return nullptr;

  909. 

  910.         static NativeMidiProgram midiProg;

  911. 

  912.         midiProg.bank    = 0;

  913.         midiProg.program = index;

  914. 

  915.         switch (index)

  916.         {

  917.         case 0:

  918.             midiProg.name = "Echo 1";

  919.             break;

  920.         case 1:

  921.             midiProg.name = "Echo 2";

  922.             break;

  923.         case 2:

  924.             midiProg.name = "Echo 3";

  925.             break;

  926.         case 3:

  927.             midiProg.name = "Simple Echo";

  928.             break;

  929.         case 4:

  930.             midiProg.name = "Canyon";

  931.             break;

  932.         case 5:

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

  934.             break;

  935.         case 6:

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

  937.             break;

  938.         case 7:

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

  940.             break;

  941.         case 8:

  942.             midiProg.name = "Feedback Echo";

  943.             break;

  944.         default:

  945.             midiProg.name = nullptr;

  946.             break;

  947.         }

  948. 

  949.         return &midiProg;

  950.     }

  951. 

  952.     // -------------------------------------------------------------------

  953. 

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

  955.     {

  956.         delete fEffect;

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

  958.     }

  959. 

  960.     PluginClassEND(FxEchoPlugin)

  961.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  962. };

  963. 

  964. // -----------------------------------------------------------------------

  965. 

  966. class FxPhaserPlugin : public FxAbstractPlugin

  967. {

  968. public:

  969.     FxPhaserPlugin(const NativeHostDescriptor* const host)

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

  971.           leakDetector_FxPhaserPlugin()

  972.     {

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

  974.     }

  975. 

  976. protected:

  977.     // -------------------------------------------------------------------

  978.     // Plugin parameter calls

  979. 

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

  981.     {

  982.         if (index >= fParamCount)

  983.             return nullptr;

  984. 

  985.         static NativeParameter param;

  986.         static NativeParameterScalePoint scalePoints[2];

  987. 

  988.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  989. 

  990.         param.name = nullptr;

  991.         param.unit = nullptr;

  992.         param.ranges.def       = 1.0f;

  993.         param.ranges.min       = 0.0f;

  994.         param.ranges.max       = 127.0f;

  995.         param.ranges.step      = 1.0f;

  996.         param.ranges.stepSmall = 1.0f;

  997.         param.ranges.stepLarge = 20.0f;

  998.         param.scalePointCount  = 0;

  999.         param.scalePoints      = nullptr;

  1000. 

  1001.         switch (index)

  1002.         {

  1003.         case 0:

  1004.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1005.             param.name = "LFO Frequency";

  1006.             param.ranges.def = 36.0f;

  1007.             break;

  1008.         case 1:

  1009.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1010.             param.name = "LFO Randomness";

  1011.             param.ranges.def = 0.0f;

  1012.             break;

  1013.         case 2:

  1014.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1015.             param.name = "LFO Type";

  1016.             param.ranges.def = 0.0f;

  1017.             param.ranges.max = 1.0f;

  1018.             param.scalePointCount = 2;

  1019.             param.scalePoints     = scalePoints;

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

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

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

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

  1024.             break;

  1025.         case 3:

  1026.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1027.             param.name = "LFO Stereo";

  1028.             param.ranges.def = 64.0f;

  1029.             break;

  1030.         case 4:

  1031.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1032.             param.name = "Depth";

  1033.             param.ranges.def = 110.0f;

  1034.             break;

  1035.         case 5:

  1036.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1037.             param.name = "Feedback";

  1038.             param.ranges.def = 64.0f;

  1039.             break;

  1040.         case 6:

  1041.             param.name = "Stages";

  1042.             param.ranges.def = 1.0f;

  1043.             param.ranges.min = 1.0f;

  1044.             param.ranges.max = 12.0f;

  1045.             break;

  1046.         case 7:

  1047.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1049.             param.ranges.def = 0.0f;

  1050.             break;

  1051.         case 8:

  1052.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1053.             param.name = "Subtract Output";

  1054.             param.ranges.def = 0.0f;

  1055.             param.ranges.max = 1.0f;

  1056.             break;

  1057.         case 9:

  1058.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1060.             param.ranges.def = 20.0f;

  1061.             break;

  1062.         case 10:

  1063.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1064.             param.name = "Hyper";

  1065.             param.ranges.def = 0.0f;

  1066.             param.ranges.max = 1.0f;

  1067.             break;

  1068.         case 11:

  1069.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1070.             param.name = "Distortion";

  1071.             param.ranges.def = 0.0f;

  1072.             break;

  1073.         case 12:

  1074.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1075.             param.name = "Analog";

  1076.             param.ranges.def = 0.0f;

  1077.             param.ranges.max = 1.0f;

  1078.             break;

  1079.         }

  1080. 

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

  1082. 

  1083.         return &param;

  1084.     }

  1085. 

  1086.     // -------------------------------------------------------------------

  1087.     // Plugin midi-program calls

  1088. 

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

  1090.     {

  1091.         if (index >= fProgramCount)

  1092.             return nullptr;

  1093. 

  1094.         static NativeMidiProgram midiProg;

  1095. 

  1096.         midiProg.bank    = 0;

  1097.         midiProg.program = index;

  1098. 

  1099.         switch (index)

  1100.         {

  1101.         case 0:

  1102.             midiProg.name = "Phaser 1";

  1103.             break;

  1104.         case 1:

  1105.             midiProg.name = "Phaser 2";

  1106.             break;

  1107.         case 2:

  1108.             midiProg.name = "Phaser 3";

  1109.             break;

  1110.         case 3:

  1111.             midiProg.name = "Phaser 4";

  1112.             break;

  1113.         case 4:

  1114.             midiProg.name = "Phaser 5";

  1115.             break;

  1116.         case 5:

  1117.             midiProg.name = "Phaser 6";

  1118.             break;

  1119.         case 6:

  1120.             midiProg.name = "APhaser 1";

  1121.             break;

  1122.         case 7:

  1123.             midiProg.name = "APhaser 2";

  1124.             break;

  1125.         case 8:

  1126.             midiProg.name = "APhaser 3";

  1127.             break;

  1128.         case 9:

  1129.             midiProg.name = "APhaser 4";

  1130.             break;

  1131.         case 10:

  1132.             midiProg.name = "APhaser 5";

  1133.             break;

  1134.         case 11:

  1135.             midiProg.name = "APhaser 6";

  1136.             break;

  1137.         default:

  1138.             midiProg.name = nullptr;

  1139.             break;

  1140.         }

  1141. 

  1142.         return &midiProg;

  1143.     }

  1144. 

  1145.     // -------------------------------------------------------------------

  1146. 

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

  1148.     {

  1149.         delete fEffect;

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

  1151.     }

  1152. 

  1153.     PluginClassEND(FxPhaserPlugin)

  1154.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1155. };

  1156. 

  1157. // -----------------------------------------------------------------------

  1158. 

  1159. class FxReverbPlugin : public FxAbstractPlugin

  1160. {

  1161. public:

  1162.     FxReverbPlugin(const NativeHostDescriptor* const host)

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

  1164.           leakDetector_FxReverbPlugin()

  1165.     {

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

  1167.     }

  1168. 

  1169. protected:

  1170.     // -------------------------------------------------------------------

  1171.     // Plugin parameter calls

  1172. 

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

  1174.     {

  1175.         if (index >= fParamCount)

  1176.             return nullptr;

  1177. 

  1178.         static NativeParameter param;

  1179.         static NativeParameterScalePoint scalePoints[3];

  1180. 

  1181.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1182. 

  1183.         param.name = nullptr;

  1184.         param.unit = nullptr;

  1185.         param.ranges.def       = 1.0f;

  1186.         param.ranges.min       = 0.0f;

  1187.         param.ranges.max       = 127.0f;

  1188.         param.ranges.step      = 1.0f;

  1189.         param.ranges.stepSmall = 1.0f;

  1190.         param.ranges.stepLarge = 20.0f;

  1191.         param.scalePointCount  = 0;

  1192.         param.scalePoints      = nullptr;

  1193. 

  1194.         switch (index)

  1195.         {

  1196.         case 0:

  1197.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1198.             param.name = "Time";

  1199.             param.ranges.def = 63.0f;

  1200.             break;

  1201.         case 1:

  1202.             param.name = "Delay";

  1203.             param.ranges.def = 24.0f;

  1204.             break;

  1205.         case 2:

  1206.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1207.             param.name = "Feedback";

  1208.             param.ranges.def = 0.0f;

  1209.             break;

  1210.         case 3:

  1211.             hints = 0x0;

  1212.             param.name = "bw";

  1213.             break;

  1214.         case 4:

  1215.             hints = 0x0;

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

  1217.             break;

  1218.         case 5:

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

  1220.             param.ranges.def = 85.0f;

  1221.             break;

  1222.         case 6:

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

  1224.             param.ranges.def = 5.0f;

  1225.             break;

  1226.         case 7:

  1227.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1228.             param.name = "Damp";

  1229.             param.ranges.def = 83.0f;

  1230.             param.ranges.min = 64.0f;

  1231.             break;

  1232.         case 8:

  1233.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1234.             param.name = "Type";

  1235.             param.ranges.def = 1.0f;

  1236.             param.ranges.max = 2.0f;

  1237.             param.scalePointCount = 3;

  1238.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1245.             break;

  1246.         case 9:

  1247.             param.name = "Room size";

  1248.             param.ranges.def = 64.0f;

  1249.             param.ranges.min = 1.0f;

  1250.             break;

  1251.         case 10:

  1252.             param.name = "Bandwidth";

  1253.             param.ranges.def = 20.0f;

  1254.             break;

  1255.         }

  1256. 

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

  1258. 

  1259.         return &param;

  1260.     }

  1261. 

  1262.     // -------------------------------------------------------------------

  1263.     // Plugin midi-program calls

  1264. 

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

  1266.     {

  1267.         if (index >= fProgramCount)

  1268.             return nullptr;

  1269. 

  1270.         static NativeMidiProgram midiProg;

  1271. 

  1272.         midiProg.bank    = 0;

  1273.         midiProg.program = index;

  1274. 

  1275.         switch (index)

  1276.         {

  1277.         case 0:

  1278.             midiProg.name = "Cathedral1";

  1279.             break;

  1280.         case 1:

  1281.             midiProg.name = "Cathedral2";

  1282.             break;

  1283.         case 2:

  1284.             midiProg.name = "Cathedral3";

  1285.             break;

  1286.         case 3:

  1287.             midiProg.name = "Hall1";

  1288.             break;

  1289.         case 4:

  1290.             midiProg.name = "Hall2";

  1291.             break;

  1292.         case 5:

  1293.             midiProg.name = "Room1";

  1294.             break;

  1295.         case 6:

  1296.             midiProg.name = "Room2";

  1297.             break;

  1298.         case 7:

  1299.             midiProg.name = "Basement";

  1300.             break;

  1301.         case 8:

  1302.             midiProg.name = "Tunnel";

  1303.             break;

  1304.         case 9:

  1305.             midiProg.name = "Echoed1";

  1306.             break;

  1307.         case 10:

  1308.             midiProg.name = "Echoed2";

  1309.             break;

  1310.         case 11:

  1311.             midiProg.name = "VeryLong1";

  1312.             break;

  1313.         case 12:

  1314.             midiProg.name = "VeryLong2";

  1315.             break;

  1316.         default:

  1317.             midiProg.name = nullptr;

  1318.             break;

  1319.         }

  1320. 

  1321.         return &midiProg;

  1322.     }

  1323. 

  1324.     // -------------------------------------------------------------------

  1325. 

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

  1327.     {

  1328.         delete fEffect;

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

  1330.     }

  1331. 

  1332.     PluginClassEND(FxReverbPlugin)

  1333.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1334. };

  1335. 

  1336. // -----------------------------------------------------------------------

  1337. 

  1338. static const NativePluginDescriptor fxAlienWahDesc = {

  1339.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1341.                                                   |NATIVE_PLUGIN_USES_PANNING

  1342.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1344.     /* audioIns  */ 2,

  1345.     /* audioOuts */ 2,

  1346.     /* midiIns   */ 0,

  1347.     /* midiOuts  */ 0,

  1348.     /* paramIns  */ 11-2,

  1349.     /* paramOuts */ 0,

  1350.     /* name      */ "ZynAlienWah",

  1351.     /* label     */ "zynalienwah",

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

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

  1354.     PluginDescriptorFILL(FxAlienWahPlugin)

  1355. };

  1356. 

  1357. static const NativePluginDescriptor fxChorusDesc = {

  1358.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1360.                                                   |NATIVE_PLUGIN_USES_PANNING

  1361.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1363.     /* audioIns  */ 2,

  1364.     /* audioOuts */ 2,

  1365.     /* midiIns   */ 0,

  1366.     /* midiOuts  */ 0,

  1367.     /* paramIns  */ 12-2,

  1368.     /* paramOuts */ 0,

  1369.     /* name      */ "ZynChorus",

  1370.     /* label     */ "zynchorus",

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

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

  1373.     PluginDescriptorFILL(FxChorusPlugin)

  1374. };

  1375. 

  1376. static const NativePluginDescriptor fxDistortionDesc = {

  1377.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1379.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1381.     /* audioIns  */ 2,

  1382.     /* audioOuts */ 2,

  1383.     /* midiIns   */ 0,

  1384.     /* midiOuts  */ 0,

  1385.     /* paramIns  */ 11-2,

  1386.     /* paramOuts */ 0,

  1387.     /* name      */ "ZynDistortion",

  1388.     /* label     */ "zyndistortion",

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

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

  1391.     PluginDescriptorFILL(FxDistortionPlugin)

  1392. };

  1393. 

  1394. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1395.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1397.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1399.     /* audioIns  */ 2,

  1400.     /* audioOuts */ 2,

  1401.     /* midiIns   */ 0,

  1402.     /* midiOuts  */ 0,

  1403.     /* paramIns  */ 10-2,

  1404.     /* paramOuts */ 0,

  1405.     /* name      */ "ZynDynamicFilter",

  1406.     /* label     */ "zyndynamicfilter",

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

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

  1409.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1410. };

  1411. 

  1412. static const NativePluginDescriptor fxEchoDesc = {

  1413.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1415.                                                   |NATIVE_PLUGIN_USES_PANNING

  1416.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1418.     /* audioIns  */ 2,

  1419.     /* audioOuts */ 2,

  1420.     /* midiIns   */ 0,

  1421.     /* midiOuts  */ 0,

  1422.     /* paramIns  */ 7-2,

  1423.     /* paramOuts */ 0,

  1424.     /* name      */ "ZynEcho",

  1425.     /* label     */ "zynecho",

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

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

  1428.     PluginDescriptorFILL(FxEchoPlugin)

  1429. };

  1430. 

  1431. static const NativePluginDescriptor fxPhaserDesc = {

  1432.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1434.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1436.     /* audioIns  */ 2,

  1437.     /* audioOuts */ 2,

  1438.     /* midiIns   */ 0,

  1439.     /* midiOuts  */ 0,

  1440.     /* paramIns  */ 15-2,

  1441.     /* paramOuts */ 0,

  1442.     /* name      */ "ZynPhaser",

  1443.     /* label     */ "zynphaser",

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

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

  1446.     PluginDescriptorFILL(FxPhaserPlugin)

  1447. };

  1448. 

  1449. static const NativePluginDescriptor fxReverbDesc = {

  1450.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1452.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1454.     /* audioIns  */ 2,

  1455.     /* audioOuts */ 2,

  1456.     /* midiIns   */ 0,

  1457.     /* midiOuts  */ 0,

  1458.     /* paramIns  */ 13-2,

  1459.     /* paramOuts */ 0,

  1460.     /* name      */ "ZynReverb",

  1461.     /* label     */ "zynreverb",

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

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

  1464.     PluginDescriptorFILL(FxReverbPlugin)

  1465. };

  1466. 

  1467. // -----------------------------------------------------------------------

  1468. 

  1469. CARLA_EXPORT

  1470. void carla_register_native_plugin_zynaddsubfx_fx();

  1471. 

  1472. CARLA_EXPORT

  1473. void carla_register_native_plugin_zynaddsubfx_fx()

  1474. {

  1475.     carla_register_native_plugin(&fxAlienWahDesc);

  1476.     carla_register_native_plugin(&fxChorusDesc);

  1477.     carla_register_native_plugin(&fxDistortionDesc);

  1478.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1479.     carla_register_native_plugin(&fxEchoDesc);

  1480.     carla_register_native_plugin(&fxPhaserDesc);

  1481.     carla_register_native_plugin(&fxReverbDesc);

  1482. }

  1483. 

  1484. // -----------------------------------------------------------------------