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

1458 lines
42KB
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. 

  20. #include "zynaddsubfx/Effects/Alienwah.h"

  21. #include "zynaddsubfx/Effects/Chorus.h"

  22. #include "zynaddsubfx/Effects/Distorsion.h"

  23. #include "zynaddsubfx/Effects/DynamicFilter.h"

  24. #include "zynaddsubfx/Effects/Echo.h"

  25. #include "zynaddsubfx/Effects/Phaser.h"

  26. #include "zynaddsubfx/Effects/Reverb.h"

  27. 

  28. #include "CarlaMathUtils.hpp"

  29. 

  30. // -----------------------------------------------------------------------

  31. 

  32. class FxAbstractPlugin : public NativePluginClass

  33. {

  34. protected:

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

  36.         : NativePluginClass(host),

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

  38.           fProgramCount(programCount),

  39.           fEffect(nullptr),

  40.           efxoutl(nullptr),

  41.           efxoutr(nullptr),

  42.           fFirstInit(true)

  43.     {

  44.         const uint32_t bufferSize(getBufferSize());

  45.         efxoutl = new float[bufferSize];

  46.         efxoutr = new float[bufferSize];

  47. 

  48.         FLOAT_CLEAR(efxoutl, bufferSize);

  49.         FLOAT_CLEAR(efxoutr, bufferSize);

  50.     }

  51. 

  52.     ~FxAbstractPlugin() override

  53.     {

  54.         if (efxoutl != nullptr)

  55.         {

  56.             delete[] efxoutl;

  57.             efxoutl = nullptr;

  58.         }

  59. 

  60.         if (efxoutr != nullptr)

  61.         {

  62.             delete[] efxoutr;

  63.             efxoutr = nullptr;

  64.         }

  65. 

  66.         if (fEffect != nullptr)

  67.         {

  68.             delete fEffect;

  69.             fEffect = nullptr;

  70.         }

  71.     }

  72. 

  73.     // -------------------------------------------------------------------

  74.     // Plugin parameter calls

  75. 

  76.     uint32_t getParameterCount() const final

  77.     {

  78.         return fParamCount;

  79.     }

  80. 

  81.     float getParameterValue(const uint32_t index) const final

  82.     {

  83.         return fEffect->getpar(index+2);

  84.     }

  85. 

  86.     // -------------------------------------------------------------------

  87.     // Plugin midi-program calls

  88. 

  89.     uint32_t getMidiProgramCount() const final

  90.     {

  91.         return fProgramCount;

  92.     }

  93. 

  94.     // -------------------------------------------------------------------

  95.     // Plugin state calls

  96. 

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

  98.     {

  99.         fFirstInit = false;

  100.         fEffect->changepar(index+2, value);

  101.     }

  102. 

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

  104.     {

  105.         fFirstInit = false;

  106.         fEffect->setpreset(program);

  107. 

  108.         const float volume(float(fEffect->getpar(0))/127.0f);

  109.         hostSetVolume(volume);

  110. 

  111.         const unsigned char pan(fEffect->getpar(1));

  112.         const float panning(float(pan)/63.5f-1.0f);

  113.         hostSetPanning(panning);

  114. 

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

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

  117.     }

  118. 

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

  120.     // Plugin process calls

  121. 

  122.     void activate() final

  123.     {

  124.         fEffect->cleanup();

  125. 

  126.         if (fFirstInit)

  127.         {

  128.             fFirstInit = false;

  129.             hostSetDryWet(0.5f);

  130.         }

  131.     }

  132. 

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

  134.     {

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

  136. 

  137.         FLOAT_COPY(outBuffer[0], efxoutl, frames);

  138.         FLOAT_COPY(outBuffer[1], efxoutr, frames);

  139.     }

  140. 

  141.     // -------------------------------------------------------------------

  142.     // Plugin dispatcher

  143. 

  144.     void bufferSizeChanged(const uint32_t bufferSize) final

  145.     {

  146.         delete[] efxoutl;

  147.         delete[] efxoutr;

  148.         efxoutl = new float[bufferSize];

  149.         efxoutr = new float[bufferSize];

  150.         FLOAT_CLEAR(efxoutl, bufferSize);

  151.         FLOAT_CLEAR(efxoutr, bufferSize);

  152. 

  153.         doReinit(bufferSize, getSampleRate());

  154.     }

  155. 

  156.     void sampleRateChanged(const double sampleRate) final

  157.     {

  158.         doReinit(getBufferSize(), sampleRate);

  159.     }

  160. 

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

  162.     {

  163.         float params[fParamCount];

  164. 

  165.         for (uint32_t i=0; i < fParamCount; ++i)

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

  167. 

  168.         reinit(bufferSize, sampleRate);

  169. 

  170.         for (uint32_t i=0; i < fParamCount; ++i)

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

  172.     }

  173. 

  174.     virtual void reinit(const uint32_t bufferSize, const double sampleRate) = 0;

  175. 

  176.     // -------------------------------------------------------------------

  177. 

  178.     const uint32_t fParamCount;

  179.     const uint32_t fProgramCount;

  180. 

  181.     Effect* fEffect;

  182.     float*  efxoutl;

  183.     float*  efxoutr;

  184.     bool    fFirstInit;

  185. };

  186. 

  187. // -----------------------------------------------------------------------

  188. 

  189. class FxAlienWahPlugin : public FxAbstractPlugin

  190. {

  191. public:

  192.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

  193.         : FxAbstractPlugin(host, 11, 4)

  194.     {

  195.         fEffect = new Alienwah(false, efxoutl, efxoutr, getSampleRate(), getBufferSize());

  196.     }

  197. 

  198. protected:

  199.     // -------------------------------------------------------------------

  200.     // Plugin parameter calls

  201. 

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

  203.     {

  204.         if (index >= fParamCount)

  205.             return nullptr;

  206. 

  207.         static NativeParameter param;

  208.         static NativeParameterScalePoint scalePoints[2];

  209. 

  210.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  211. 

  212.         param.name = nullptr;

  213.         param.unit = nullptr;

  214.         param.ranges.def       = 1.0f;

  215.         param.ranges.min       = 0.0f;

  216.         param.ranges.max       = 127.0f;

  217.         param.ranges.step      = 1.0f;

  218.         param.ranges.stepSmall = 1.0f;

  219.         param.ranges.stepLarge = 20.0f;

  220.         param.scalePointCount  = 0;

  221.         param.scalePoints      = nullptr;

  222. 

  223.         switch (index)

  224.         {

  225.         case 0:

  226.             hints |= PARAMETER_IS_AUTOMABLE;

  227.             param.name = "LFO Frequency";

  228.             param.ranges.def = 70.0f;

  229.             break;

  230.         case 1:

  231.             hints |= PARAMETER_IS_AUTOMABLE;

  232.             param.name = "LFO Randomness";

  233.             param.ranges.def = 0.0f;

  234.             break;

  235.         case 2:

  236.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  237.             param.name = "LFO Type";

  238.             param.ranges.def = 0.0f;

  239.             param.ranges.max = 1.0f;

  240.             param.scalePointCount = 2;

  241.             param.scalePoints     = scalePoints;

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

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

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

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

  246.             break;

  247.         case 3:

  248.             hints |= PARAMETER_IS_AUTOMABLE;

  249.             param.name = "LFO Stereo";

  250.             param.ranges.def = 62.0f;

  251.             break;

  252.         case 4:

  253.             hints |= PARAMETER_IS_AUTOMABLE;

  254.             param.name = "Depth";

  255.             param.ranges.def = 60.0f;

  256.             break;

  257.         case 5:

  258.             hints |= PARAMETER_IS_AUTOMABLE;

  259.             param.name = "Feedback";

  260.             param.ranges.def = 105.0f;

  261.             break;

  262.         case 6:

  263.             param.name = "Delay";

  264.             param.ranges.def = 25.0f;

  265.             param.ranges.min = 1.0f;

  266.             param.ranges.max = 100.0f;

  267.             break;

  268.         case 7:

  269.             hints |= PARAMETER_IS_AUTOMABLE;

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

  271.             param.ranges.def = 0.0f;

  272.             break;

  273.         case 8:

  274.             hints |= PARAMETER_IS_AUTOMABLE;

  275.             param.name = "Phase";

  276.             param.ranges.def = 64.0f;

  277.             break;

  278.         }

  279. 

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

  281. 

  282.         return &param;

  283.     }

  284. 

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

  286.     // Plugin midi-program calls

  287. 

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

  289.     {

  290.         if (index >= fProgramCount)

  291.             return nullptr;

  292. 

  293.         static NativeMidiProgram midiProg;

  294. 

  295.         midiProg.bank    = 0;

  296.         midiProg.program = index;

  297. 

  298.         switch (index)

  299.         {

  300.         case 0:

  301.             midiProg.name = "AlienWah1";

  302.             break;

  303.         case 1:

  304.             midiProg.name = "AlienWah2";

  305.             break;

  306.         case 2:

  307.             midiProg.name = "AlienWah3";

  308.             break;

  309.         case 3:

  310.             midiProg.name = "AlienWah4";

  311.             break;

  312.         default:

  313.             midiProg.name = nullptr;

  314.             break;

  315.         }

  316. 

  317.         return &midiProg;

  318.     }

  319. 

  320.     // -------------------------------------------------------------------

  321. 

  322.     void reinit(const uint32_t bufferSize, const double sampleRate)

  323.     {

  324.         delete fEffect;

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

  326.     }

  327. 

  328.     PluginClassEND(FxAlienWahPlugin)

  329.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  330. };

  331. 

  332. // -----------------------------------------------------------------------

  333. 

  334. class FxChorusPlugin : public FxAbstractPlugin

  335. {

  336. public:

  337.     FxChorusPlugin(const NativeHostDescriptor* const host)

  338.         : FxAbstractPlugin(host, 12, 10)

  339.     {

  340.         fEffect = new Chorus(false, efxoutl, efxoutr, getSampleRate(), getBufferSize());

  341.     }

  342. 

  343. protected:

  344.     // -------------------------------------------------------------------

  345.     // Plugin parameter calls

  346. 

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

  348.     {

  349.         if (index >= fParamCount)

  350.             return nullptr;

  351. 

  352.         static NativeParameter param;

  353.         static NativeParameterScalePoint scalePoints[2];

  354. 

  355.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  356. 

  357.         param.name = nullptr;

  358.         param.unit = nullptr;

  359.         param.ranges.def       = 1.0f;

  360.         param.ranges.min       = 0.0f;

  361.         param.ranges.max       = 127.0f;

  362.         param.ranges.step      = 1.0f;

  363.         param.ranges.stepSmall = 1.0f;

  364.         param.ranges.stepLarge = 20.0f;

  365.         param.scalePointCount  = 0;

  366.         param.scalePoints      = nullptr;

  367. 

  368.         switch (index)

  369.         {

  370.         case 0:

  371.             hints |= PARAMETER_IS_AUTOMABLE;

  372.             param.name = "LFO Frequency";

  373.             param.ranges.def = 50.0f;

  374.             break;

  375.         case 1:

  376.             hints |= PARAMETER_IS_AUTOMABLE;

  377.             param.name = "LFO Randomness";

  378.             param.ranges.def = 0.0f;

  379.             break;

  380.         case 2:

  381.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  382.             param.name = "LFO Type";

  383.             param.ranges.def = 0.0f;

  384.             param.ranges.max = 1.0f;

  385.             param.scalePointCount = 2;

  386.             param.scalePoints     = scalePoints;

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

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

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

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

  391.             break;

  392.         case 3:

  393.             hints |= PARAMETER_IS_AUTOMABLE;

  394.             param.name = "LFO Stereo";

  395.             param.ranges.def = 90.0f;

  396.             break;

  397.         case 4:

  398.             hints |= PARAMETER_IS_AUTOMABLE;

  399.             param.name = "Depth";

  400.             param.ranges.def = 40.0f;

  401.             break;

  402.         case 5:

  403.             hints |= PARAMETER_IS_AUTOMABLE;

  404.             param.name = "Delay";

  405.             param.ranges.def = 85.0f;

  406.             break;

  407.         case 6:

  408.             hints |= PARAMETER_IS_AUTOMABLE;

  409.             param.name = "Feedback";

  410.             param.ranges.def = 64.0f;

  411.             break;

  412.         case 7:

  413.             hints |= PARAMETER_IS_AUTOMABLE;

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

  415.             param.ranges.def = 119.0f;

  416.             break;

  417.         case 8:

  418.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  419.             param.name = "Flange Mode";

  420.             param.ranges.def = 0.0f;

  421.             param.ranges.max = 1.0f;

  422.             break;

  423.         case 9:

  424.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  425.             param.name = "Subtract Output";

  426.             param.ranges.def = 0.0f;

  427.             param.ranges.max = 1.0f;

  428.             break;

  429.         }

  430. 

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

  432. 

  433.         return &param;

  434.     }

  435. 

  436.     // -------------------------------------------------------------------

  437.     // Plugin midi-program calls

  438. 

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

  440.     {

  441.         if (index >= fProgramCount)

  442.             return nullptr;

  443. 

  444.         static NativeMidiProgram midiProg;

  445. 

  446.         midiProg.bank    = 0;

  447.         midiProg.program = index;

  448. 

  449.         switch (index)

  450.         {

  451.         case 0:

  452.             midiProg.name = "Chorus1";

  453.             break;

  454.         case 1:

  455.             midiProg.name = "Chorus2";

  456.             break;

  457.         case 2:

  458.             midiProg.name = "Chorus3";

  459.             break;

  460.         case 3:

  461.             midiProg.name = "Celeste1";

  462.             break;

  463.         case 4:

  464.             midiProg.name = "Celeste2";

  465.             break;

  466.         case 5:

  467.             midiProg.name = "Flange1";

  468.             break;

  469.         case 6:

  470.             midiProg.name = "Flange2";

  471.             break;

  472.         case 7:

  473.             midiProg.name = "Flange3";

  474.             break;

  475.         case 8:

  476.             midiProg.name = "Flange4";

  477.             break;

  478.         case 9:

  479.             midiProg.name = "Flange5";

  480.             break;

  481.         default:

  482.             midiProg.name = nullptr;

  483.             break;

  484.         }

  485. 

  486.         return &midiProg;

  487.     }

  488. 

  489.     // -------------------------------------------------------------------

  490. 

  491.     void reinit(const uint32_t bufferSize, const double sampleRate)

  492.     {

  493.         delete fEffect;

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

  495.     }

  496. 

  497.     PluginClassEND(FxChorusPlugin)

  498.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  499. };

  500. 

  501. // -----------------------------------------------------------------------

  502. 

  503. class FxDistortionPlugin : public FxAbstractPlugin

  504. {

  505. public:

  506.     FxDistortionPlugin(const NativeHostDescriptor* const host)

  507.         : FxAbstractPlugin(host, 11, 6)

  508.     {

  509.         fEffect = new Distorsion(false, efxoutl, efxoutr, getSampleRate(), getBufferSize());

  510.     }

  511. 

  512. protected:

  513.     // -------------------------------------------------------------------

  514.     // Plugin parameter calls

  515. 

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

  517.     {

  518.         if (index >= fParamCount)

  519.             return nullptr;

  520. 

  521.         static NativeParameter param;

  522.         static NativeParameterScalePoint scalePoints[14];

  523. 

  524.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  525. 

  526.         param.name = nullptr;

  527.         param.unit = nullptr;

  528.         param.ranges.def       = 1.0f;

  529.         param.ranges.min       = 0.0f;

  530.         param.ranges.max       = 127.0f;

  531.         param.ranges.step      = 1.0f;

  532.         param.ranges.stepSmall = 1.0f;

  533.         param.ranges.stepLarge = 20.0f;

  534.         param.scalePointCount  = 0;

  535.         param.scalePoints      = nullptr;

  536. 

  537.         switch (index)

  538.         {

  539.         case 0:

  540.             hints |= PARAMETER_IS_AUTOMABLE;

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

  542.             param.ranges.def = 35.0f;

  543.             break;

  544.         case 1:

  545.             hints |= PARAMETER_IS_AUTOMABLE;

  546.             param.name = "Drive";

  547.             param.ranges.def = 56.0f;

  548.             break;

  549.         case 2:

  550.             hints |= PARAMETER_IS_AUTOMABLE;

  551.             param.name = "Level";

  552.             param.ranges.def = 70.0f;

  553.             break;

  554.         case 3:

  555.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_USES_SCALEPOINTS;

  556.             param.name = "Type";

  557.             param.ranges.def = 0.0f;

  558.             param.ranges.max = 13.0f;

  559.             param.scalePointCount = 14;

  560.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  589.             break;

  590.         case 4:

  591.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  592.             param.name = "Negate";

  593.             param.ranges.def = 0.0f;

  594.             param.ranges.max = 1.0f;

  595.             break;

  596.         case 5:

  597.             hints |= PARAMETER_IS_AUTOMABLE;

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

  599.             param.ranges.def = 96.0f;

  600.             break;

  601.         case 6:

  602.             hints |= PARAMETER_IS_AUTOMABLE;

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

  604.             param.ranges.def = 0.0f;

  605.             break;

  606.         case 7:

  607.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  608.             param.name = "Stereo";

  609.             param.ranges.def = 0.0f;

  610.             param.ranges.max = 1.0f;

  611.             break;

  612.         case 8:

  613.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

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

  615.             param.ranges.def = 0.0f;

  616.             param.ranges.max = 1.0f;

  617.             break;

  618.         }

  619. 

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

  621. 

  622.         return &param;

  623.     }

  624. 

  625.     // -------------------------------------------------------------------

  626.     // Plugin midi-program calls

  627. 

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

  629.     {

  630.         if (index >= fProgramCount)

  631.             return nullptr;

  632. 

  633.         static NativeMidiProgram midiProg;

  634. 

  635.         midiProg.bank    = 0;

  636.         midiProg.program = index;

  637. 

  638.         switch (index)

  639.         {

  640.         case 0:

  641.             midiProg.name = "Overdrive 1";

  642.             break;

  643.         case 1:

  644.             midiProg.name = "Overdrive 2";

  645.             break;

  646.         case 2:

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

  648.             break;

  649.         case 3:

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

  651.             break;

  652.         case 4:

  653.             midiProg.name = "Guitar Amp";

  654.             break;

  655.         case 5:

  656.             midiProg.name = "Quantisize";

  657.             break;

  658.         default:

  659.             midiProg.name = nullptr;

  660.             break;

  661.         }

  662. 

  663.         return &midiProg;

  664.     }

  665. 

  666.     // -------------------------------------------------------------------

  667. 

  668.     void reinit(const uint32_t bufferSize, const double sampleRate)

  669.     {

  670.         delete fEffect;

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

  672.     }

  673. 

  674.     PluginClassEND(FxDistortionPlugin)

  675.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  676. };

  677. 

  678. // -----------------------------------------------------------------------

  679. 

  680. class FxDynamicFilterPlugin : public FxAbstractPlugin

  681. {

  682. public:

  683.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

  684.         : FxAbstractPlugin(host, 10, 5)

  685.     {

  686.         fEffect = new DynamicFilter(false, efxoutl, efxoutr, getSampleRate(), getBufferSize());

  687.     }

  688. 

  689. protected:

  690.     // -------------------------------------------------------------------

  691.     // Plugin parameter calls

  692. 

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

  694.     {

  695.         if (index >= fParamCount)

  696.             return nullptr;

  697. 

  698.         static NativeParameter param;

  699.         static NativeParameterScalePoint scalePoints[2];

  700. 

  701.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  702. 

  703.         param.name = nullptr;

  704.         param.unit = nullptr;

  705.         param.ranges.def       = 1.0f;

  706.         param.ranges.min       = 0.0f;

  707.         param.ranges.max       = 127.0f;

  708.         param.ranges.step      = 1.0f;

  709.         param.ranges.stepSmall = 1.0f;

  710.         param.ranges.stepLarge = 20.0f;

  711.         param.scalePointCount  = 0;

  712.         param.scalePoints      = nullptr;

  713. 

  714.         switch (index)

  715.         {

  716.         case 0:

  717.             hints |= PARAMETER_IS_AUTOMABLE;

  718.             param.name = "LFO Frequency";

  719.             param.ranges.def = 80.0f;

  720.             break;

  721.         case 1:

  722.             hints |= PARAMETER_IS_AUTOMABLE;

  723.             param.name = "LFO Randomness";

  724.             param.ranges.def = 0.0f;

  725.             break;

  726.         case 2:

  727.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  728.             param.name = "LFO Type";

  729.             param.ranges.def = 0.0f;

  730.             param.ranges.max = 1.0f;

  731.             param.scalePointCount = 2;

  732.             param.scalePoints     = scalePoints;

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

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

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

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

  737.             break;

  738.         case 3:

  739.             hints |= PARAMETER_IS_AUTOMABLE;

  740.             param.name = "LFO Stereo";

  741.             param.ranges.def = 64.0f;

  742.             break;

  743.         case 4:

  744.             hints |= PARAMETER_IS_AUTOMABLE;

  745.             param.name = "LFO Depth";

  746.             param.ranges.def = 0.0f;

  747.             break;

  748.         case 5:

  749.             hints |= PARAMETER_IS_AUTOMABLE;

  750.             param.name = "Amp sns";

  751.             param.ranges.def = 90.0f;

  752.             break;

  753.         case 6:

  754.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

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

  756.             param.ranges.def = 0.0f;

  757.             param.ranges.max = 1.0f;

  758.             break;

  759.         case 7:

  760.             hints |= PARAMETER_IS_AUTOMABLE;

  761.             param.name = "Amp Smooth";

  762.             param.ranges.def = 60.0f;

  763.             break;

  764.         }

  765. 

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

  767. 

  768.         return &param;

  769.     }

  770. 

  771.     // -------------------------------------------------------------------

  772.     // Plugin midi-program calls

  773. 

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

  775.     {

  776.         if (index >= fProgramCount)

  777.             return nullptr;

  778. 

  779.         static NativeMidiProgram midiProg;

  780. 

  781.         midiProg.bank    = 0;

  782.         midiProg.program = index;

  783. 

  784.         switch (index)

  785.         {

  786.         case 0:

  787.             midiProg.name = "WahWah";

  788.             break;

  789.         case 1:

  790.             midiProg.name = "AutoWah";

  791.             break;

  792.         case 2:

  793.             midiProg.name = "Sweep";

  794.             break;

  795.         case 3:

  796.             midiProg.name = "VocalMorph1";

  797.             break;

  798.         case 4:

  799.             midiProg.name = "VocalMorph2";

  800.             break;

  801.         default:

  802.             midiProg.name = nullptr;

  803.             break;

  804.         }

  805. 

  806.         return &midiProg;

  807.     }

  808. 

  809.     // -------------------------------------------------------------------

  810. 

  811.     void reinit(const uint32_t bufferSize, const double sampleRate)

  812.     {

  813.         delete fEffect;

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

  815.     }

  816. 

  817.     PluginClassEND(FxDynamicFilterPlugin)

  818.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  819. };

  820. 

  821. // -----------------------------------------------------------------------

  822. 

  823. class FxEchoPlugin : public FxAbstractPlugin

  824. {

  825. public:

  826.     FxEchoPlugin(const NativeHostDescriptor* const host)

  827.         : FxAbstractPlugin(host, 7, 9)

  828.     {

  829.         fEffect = new Echo(false, efxoutl, efxoutr, getSampleRate(), getBufferSize());

  830.     }

  831. 

  832. protected:

  833.     // -------------------------------------------------------------------

  834.     // Plugin parameter calls

  835. 

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

  837.     {

  838.         if (index >= fParamCount)

  839.             return nullptr;

  840. 

  841.         static NativeParameter param;

  842. 

  843.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  844. 

  845.         param.name = nullptr;

  846.         param.unit = nullptr;

  847.         param.ranges.def       = 1.0f;

  848.         param.ranges.min       = 0.0f;

  849.         param.ranges.max       = 127.0f;

  850.         param.ranges.step      = 1.0f;

  851.         param.ranges.stepSmall = 1.0f;

  852.         param.ranges.stepLarge = 20.0f;

  853.         param.scalePointCount  = 0;

  854.         param.scalePoints      = nullptr;

  855. 

  856.         switch (index)

  857.         {

  858.         case 0:

  859.             hints |= PARAMETER_IS_AUTOMABLE;

  860.             param.name = "Delay";

  861.             param.ranges.def = 35.0f;

  862.             break;

  863.         case 1:

  864.             hints |= PARAMETER_IS_AUTOMABLE;

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

  866.             param.ranges.def = 64.0f;

  867.             break;

  868.         case 2:

  869.             hints |= PARAMETER_IS_AUTOMABLE;

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

  871.             param.ranges.def = 30.0f;

  872.             break;

  873.         case 3:

  874.             hints |= PARAMETER_IS_AUTOMABLE;

  875.             param.name = "Feedback";

  876.             param.ranges.def = 59.0f;

  877.             break;

  878.         case 4:

  879.             hints |= PARAMETER_IS_AUTOMABLE;

  880.             param.name = "High Damp";

  881.             param.ranges.def = 0.0f;

  882.             break;

  883.         }

  884. 

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

  886. 

  887.         return &param;

  888.     }

  889. 

  890.     // -------------------------------------------------------------------

  891.     // Plugin midi-program calls

  892. 

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

  894.     {

  895.         if (index >= fProgramCount)

  896.             return nullptr;

  897. 

  898.         static NativeMidiProgram midiProg;

  899. 

  900.         midiProg.bank    = 0;

  901.         midiProg.program = index;

  902. 

  903.         switch (index)

  904.         {

  905.         case 0:

  906.             midiProg.name = "Echo 1";

  907.             break;

  908.         case 1:

  909.             midiProg.name = "Echo 2";

  910.             break;

  911.         case 2:

  912.             midiProg.name = "Echo 3";

  913.             break;

  914.         case 3:

  915.             midiProg.name = "Simple Echo";

  916.             break;

  917.         case 4:

  918.             midiProg.name = "Canyon";

  919.             break;

  920.         case 5:

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

  922.             break;

  923.         case 6:

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

  925.             break;

  926.         case 7:

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

  928.             break;

  929.         case 8:

  930.             midiProg.name = "Feedback Echo";

  931.             break;

  932.         default:

  933.             midiProg.name = nullptr;

  934.             break;

  935.         }

  936. 

  937.         return &midiProg;

  938.     }

  939. 

  940.     // -------------------------------------------------------------------

  941. 

  942.     void reinit(const uint32_t bufferSize, const double sampleRate)

  943.     {

  944.         delete fEffect;

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

  946.     }

  947. 

  948.     PluginClassEND(FxEchoPlugin)

  949.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  950. };

  951. 

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

  953. 

  954. class FxPhaserPlugin : public FxAbstractPlugin

  955. {

  956. public:

  957.     FxPhaserPlugin(const NativeHostDescriptor* const host)

  958.         : FxAbstractPlugin(host, 15, 12)

  959.     {

  960.         fEffect = new Phaser(false, efxoutl, efxoutr, getSampleRate(), getBufferSize());

  961.     }

  962. 

  963. protected:

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

  965.     // Plugin parameter calls

  966. 

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

  968.     {

  969.         if (index >= fParamCount)

  970.             return nullptr;

  971. 

  972.         static NativeParameter param;

  973.         static NativeParameterScalePoint scalePoints[2];

  974. 

  975.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  976. 

  977.         param.name = nullptr;

  978.         param.unit = nullptr;

  979.         param.ranges.def       = 1.0f;

  980.         param.ranges.min       = 0.0f;

  981.         param.ranges.max       = 127.0f;

  982.         param.ranges.step      = 1.0f;

  983.         param.ranges.stepSmall = 1.0f;

  984.         param.ranges.stepLarge = 20.0f;

  985.         param.scalePointCount  = 0;

  986.         param.scalePoints      = nullptr;

  987. 

  988.         switch (index)

  989.         {

  990.         case 0:

  991.             hints |= PARAMETER_IS_AUTOMABLE;

  992.             param.name = "LFO Frequency";

  993.             param.ranges.def = 36.0f;

  994.             break;

  995.         case 1:

  996.             hints |= PARAMETER_IS_AUTOMABLE;

  997.             param.name = "LFO Randomness";

  998.             param.ranges.def = 0.0f;

  999.             break;

  1000.         case 2:

  1001.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  1002.             param.name = "LFO Type";

  1003.             param.ranges.def = 0.0f;

  1004.             param.ranges.max = 1.0f;

  1005.             param.scalePointCount = 2;

  1006.             param.scalePoints     = scalePoints;

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

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

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

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

  1011.             break;

  1012.         case 3:

  1013.             hints |= PARAMETER_IS_AUTOMABLE;

  1014.             param.name = "LFO Stereo";

  1015.             param.ranges.def = 64.0f;

  1016.             break;

  1017.         case 4:

  1018.             hints |= PARAMETER_IS_AUTOMABLE;

  1019.             param.name = "Depth";

  1020.             param.ranges.def = 110.0f;

  1021.             break;

  1022.         case 5:

  1023.             hints |= PARAMETER_IS_AUTOMABLE;

  1024.             param.name = "Feedback";

  1025.             param.ranges.def = 64.0f;

  1026.             break;

  1027.         case 6:

  1028.             param.name = "Stages";

  1029.             param.ranges.def = 1.0f;

  1030.             param.ranges.min = 1.0f;

  1031.             param.ranges.max = 12.0f;

  1032.             break;

  1033.         case 7:

  1034.             hints |= PARAMETER_IS_AUTOMABLE;

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

  1036.             param.ranges.def = 0.0f;

  1037.             break;

  1038.         case 8:

  1039.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1040.             param.name = "Subtract Output";

  1041.             param.ranges.def = 0.0f;

  1042.             param.ranges.max = 1.0f;

  1043.             break;

  1044.         case 9:

  1045.             hints |= PARAMETER_IS_AUTOMABLE;

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

  1047.             param.ranges.def = 20.0f;

  1048.             break;

  1049.         case 10:

  1050.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1051.             param.name = "Hyper";

  1052.             param.ranges.def = 0.0f;

  1053.             param.ranges.max = 1.0f;

  1054.             break;

  1055.         case 11:

  1056.             hints |= PARAMETER_IS_AUTOMABLE;

  1057.             param.name = "Distortion";

  1058.             param.ranges.def = 0.0f;

  1059.             break;

  1060.         case 12:

  1061.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1062.             param.name = "Analog";

  1063.             param.ranges.def = 0.0f;

  1064.             param.ranges.max = 1.0f;

  1065.             break;

  1066.         }

  1067. 

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

  1069. 

  1070.         return &param;

  1071.     }

  1072. 

  1073.     // -------------------------------------------------------------------

  1074.     // Plugin midi-program calls

  1075. 

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

  1077.     {

  1078.         if (index >= fProgramCount)

  1079.             return nullptr;

  1080. 

  1081.         static NativeMidiProgram midiProg;

  1082. 

  1083.         midiProg.bank    = 0;

  1084.         midiProg.program = index;

  1085. 

  1086.         switch (index)

  1087.         {

  1088.         case 0:

  1089.             midiProg.name = "Phaser 1";

  1090.             break;

  1091.         case 1:

  1092.             midiProg.name = "Phaser 2";

  1093.             break;

  1094.         case 2:

  1095.             midiProg.name = "Phaser 3";

  1096.             break;

  1097.         case 3:

  1098.             midiProg.name = "Phaser 4";

  1099.             break;

  1100.         case 4:

  1101.             midiProg.name = "Phaser 5";

  1102.             break;

  1103.         case 5:

  1104.             midiProg.name = "Phaser 6";

  1105.             break;

  1106.         case 6:

  1107.             midiProg.name = "APhaser 1";

  1108.             break;

  1109.         case 7:

  1110.             midiProg.name = "APhaser 2";

  1111.             break;

  1112.         case 8:

  1113.             midiProg.name = "APhaser 3";

  1114.             break;

  1115.         case 9:

  1116.             midiProg.name = "APhaser 4";

  1117.             break;

  1118.         case 10:

  1119.             midiProg.name = "APhaser 5";

  1120.             break;

  1121.         case 11:

  1122.             midiProg.name = "APhaser 6";

  1123.             break;

  1124.         default:

  1125.             midiProg.name = nullptr;

  1126.             break;

  1127.         }

  1128. 

  1129.         return &midiProg;

  1130.     }

  1131. 

  1132.     // -------------------------------------------------------------------

  1133. 

  1134.     void reinit(const uint32_t bufferSize, const double sampleRate)

  1135.     {

  1136.         delete fEffect;

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

  1138.     }

  1139. 

  1140.     PluginClassEND(FxPhaserPlugin)

  1141.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1142. };

  1143. 

  1144. // -----------------------------------------------------------------------

  1145. 

  1146. class FxReverbPlugin : public FxAbstractPlugin

  1147. {

  1148. public:

  1149.     FxReverbPlugin(const NativeHostDescriptor* const host)

  1150.         : FxAbstractPlugin(host, 13, 13)

  1151.     {

  1152.         fEffect = new Reverb(false, efxoutl, efxoutr, getSampleRate(), getBufferSize());

  1153.     }

  1154. 

  1155. protected:

  1156.     // -------------------------------------------------------------------

  1157.     // Plugin parameter calls

  1158. 

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

  1160.     {

  1161.         if (index >= fParamCount)

  1162.             return nullptr;

  1163. 

  1164.         static NativeParameter param;

  1165.         static NativeParameterScalePoint scalePoints[3];

  1166. 

  1167.         int hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;

  1168. 

  1169.         param.name = nullptr;

  1170.         param.unit = nullptr;

  1171.         param.ranges.def       = 1.0f;

  1172.         param.ranges.min       = 0.0f;

  1173.         param.ranges.max       = 127.0f;

  1174.         param.ranges.step      = 1.0f;

  1175.         param.ranges.stepSmall = 1.0f;

  1176.         param.ranges.stepLarge = 20.0f;

  1177.         param.scalePointCount  = 0;

  1178.         param.scalePoints      = nullptr;

  1179. 

  1180.         switch (index)

  1181.         {

  1182.         case 0:

  1183.             hints |= PARAMETER_IS_AUTOMABLE;

  1184.             param.name = "Time";

  1185.             param.ranges.def = 63.0f;

  1186.             break;

  1187.         case 1:

  1188.             param.name = "Delay";

  1189.             param.ranges.def = 24.0f;

  1190.             break;

  1191.         case 2:

  1192.             hints |= PARAMETER_IS_AUTOMABLE;

  1193.             param.name = "Feedback";

  1194.             param.ranges.def = 0.0f;

  1195.             break;

  1196.         case 3:

  1197.             hints = 0x0;

  1198.             param.name = "bw";

  1199.             break;

  1200.         case 4:

  1201.             hints = 0x0;

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

  1203.             break;

  1204.         case 5:

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

  1206.             param.ranges.def = 85.0f;

  1207.             break;

  1208.         case 6:

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

  1210.             param.ranges.def = 5.0f;

  1211.             break;

  1212.         case 7:

  1213.             hints |= PARAMETER_IS_AUTOMABLE;

  1214.             param.name = "Damp";

  1215.             param.ranges.def = 83.0f;

  1216.             param.ranges.min = 64.0f;

  1217.             break;

  1218.         case 8:

  1219.             hints |= PARAMETER_USES_SCALEPOINTS;

  1220.             param.name = "Type";

  1221.             param.ranges.def = 1.0f;

  1222.             param.ranges.max = 2.0f;

  1223.             param.scalePointCount = 3;

  1224.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1231.             break;

  1232.         case 9:

  1233.             param.name = "Room size";

  1234.             param.ranges.def = 64.0f;

  1235.             param.ranges.min = 1.0f;

  1236.             break;

  1237.         case 10:

  1238.             param.name = "Bandwidth";

  1239.             param.ranges.def = 20.0f;

  1240.             break;

  1241.         }

  1242. 

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

  1244. 

  1245.         return &param;

  1246.     }

  1247. 

  1248.     // -------------------------------------------------------------------

  1249.     // Plugin midi-program calls

  1250. 

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

  1252.     {

  1253.         if (index >= fProgramCount)

  1254.             return nullptr;

  1255. 

  1256.         static NativeMidiProgram midiProg;

  1257. 

  1258.         midiProg.bank    = 0;

  1259.         midiProg.program = index;

  1260. 

  1261.         switch (index)

  1262.         {

  1263.         case 0:

  1264.             midiProg.name = "Cathedral1";

  1265.             break;

  1266.         case 1:

  1267.             midiProg.name = "Cathedral2";

  1268.             break;

  1269.         case 2:

  1270.             midiProg.name = "Cathedral3";

  1271.             break;

  1272.         case 3:

  1273.             midiProg.name = "Hall1";

  1274.             break;

  1275.         case 4:

  1276.             midiProg.name = "Hall2";

  1277.             break;

  1278.         case 5:

  1279.             midiProg.name = "Room1";

  1280.             break;

  1281.         case 6:

  1282.             midiProg.name = "Room2";

  1283.             break;

  1284.         case 7:

  1285.             midiProg.name = "Basement";

  1286.             break;

  1287.         case 8:

  1288.             midiProg.name = "Tunnel";

  1289.             break;

  1290.         case 9:

  1291.             midiProg.name = "Echoed1";

  1292.             break;

  1293.         case 10:

  1294.             midiProg.name = "Echoed2";

  1295.             break;

  1296.         case 11:

  1297.             midiProg.name = "VeryLong1";

  1298.             break;

  1299.         case 12:

  1300.             midiProg.name = "VeryLong2";

  1301.             break;

  1302.         default:

  1303.             midiProg.name = nullptr;

  1304.             break;

  1305.         }

  1306. 

  1307.         return &midiProg;

  1308.     }

  1309. 

  1310.     // -------------------------------------------------------------------

  1311. 

  1312.     void reinit(const uint32_t bufferSize, const double sampleRate)

  1313.     {

  1314.         delete fEffect;

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

  1316.     }

  1317. 

  1318.     PluginClassEND(FxReverbPlugin)

  1319.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1320. };

  1321. 

  1322. // -----------------------------------------------------------------------

  1323. 

  1324. static const NativePluginDescriptor fxAlienWahDesc = {

  1325.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  1326.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1328.     /* audioIns  */ 2,

  1329.     /* audioOuts */ 2,

  1330.     /* midiIns   */ 0,

  1331.     /* midiOuts  */ 0,

  1332.     /* paramIns  */ 11-2,

  1333.     /* paramOuts */ 0,

  1334.     /* name      */ "ZynAlienWah",

  1335.     /* label     */ "zynalienwah",

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

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

  1338.     PluginDescriptorFILL(FxAlienWahPlugin)

  1339. };

  1340. 

  1341. static const NativePluginDescriptor fxChorusDesc = {

  1342.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  1343.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1345.     /* audioIns  */ 2,

  1346.     /* audioOuts */ 2,

  1347.     /* midiIns   */ 0,

  1348.     /* midiOuts  */ 0,

  1349.     /* paramIns  */ 12-2,

  1350.     /* paramOuts */ 0,

  1351.     /* name      */ "ZynChorus",

  1352.     /* label     */ "zynchorus",

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

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

  1355.     PluginDescriptorFILL(FxChorusPlugin)

  1356. };

  1357. 

  1358. static const NativePluginDescriptor fxDistortionDesc = {

  1359.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  1360.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1362.     /* audioIns  */ 2,

  1363.     /* audioOuts */ 2,

  1364.     /* midiIns   */ 0,

  1365.     /* midiOuts  */ 0,

  1366.     /* paramIns  */ 11-2,

  1367.     /* paramOuts */ 0,

  1368.     /* name      */ "ZynDistortion",

  1369.     /* label     */ "zyndistortion",

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

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

  1372.     PluginDescriptorFILL(FxDistortionPlugin)

  1373. };

  1374. 

  1375. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1376.     /* category  */ PLUGIN_CATEGORY_FILTER,

  1377.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1379.     /* audioIns  */ 2,

  1380.     /* audioOuts */ 2,

  1381.     /* midiIns   */ 0,

  1382.     /* midiOuts  */ 0,

  1383.     /* paramIns  */ 10-2,

  1384.     /* paramOuts */ 0,

  1385.     /* name      */ "ZynDynamicFilter",

  1386.     /* label     */ "zyndynamicfilter",

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

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

  1389.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1390. };

  1391. 

  1392. static const NativePluginDescriptor fxEchoDesc = {

  1393.     /* category  */ PLUGIN_CATEGORY_DELAY,

  1394.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1396.     /* audioIns  */ 2,

  1397.     /* audioOuts */ 2,

  1398.     /* midiIns   */ 0,

  1399.     /* midiOuts  */ 0,

  1400.     /* paramIns  */ 7-2,

  1401.     /* paramOuts */ 0,

  1402.     /* name      */ "ZynEcho",

  1403.     /* label     */ "zynecho",

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

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

  1406.     PluginDescriptorFILL(FxEchoPlugin)

  1407. };

  1408. 

  1409. static const NativePluginDescriptor fxPhaserDesc = {

  1410.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  1411.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1413.     /* audioIns  */ 2,

  1414.     /* audioOuts */ 2,

  1415.     /* midiIns   */ 0,

  1416.     /* midiOuts  */ 0,

  1417.     /* paramIns  */ 15-2,

  1418.     /* paramOuts */ 0,

  1419.     /* name      */ "ZynPhaser",

  1420.     /* label     */ "zynphaser",

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

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

  1423.     PluginDescriptorFILL(FxPhaserPlugin)

  1424. };

  1425. 

  1426. static const NativePluginDescriptor fxReverbDesc = {

  1427.     /* category  */ PLUGIN_CATEGORY_DELAY,

  1428.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1430.     /* audioIns  */ 2,

  1431.     /* audioOuts */ 2,

  1432.     /* midiIns   */ 0,

  1433.     /* midiOuts  */ 0,

  1434.     /* paramIns  */ 13-2,

  1435.     /* paramOuts */ 0,

  1436.     /* name      */ "ZynReverb",

  1437.     /* label     */ "zynreverb",

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

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

  1440.     PluginDescriptorFILL(FxReverbPlugin)

  1441. };

  1442. 

  1443. // -----------------------------------------------------------------------

  1444. 

  1445. CARLA_EXPORT

  1446. void carla_register_native_plugin_zynaddsubfx_fx()

  1447. {

  1448.     carla_register_native_plugin(&fxAlienWahDesc);

  1449.     carla_register_native_plugin(&fxChorusDesc);

  1450.     carla_register_native_plugin(&fxDistortionDesc);

  1451.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1452.     carla_register_native_plugin(&fxEchoDesc);

  1453.     carla_register_native_plugin(&fxPhaserDesc);

  1454.     carla_register_native_plugin(&fxReverbDesc);

  1455. }

  1456. 

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