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.
949 Commits
16 Branches
187MB
Tree: c41646ff00
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c41646ff00'
${ noResults }
Carla/source/modules/carla_native/zynaddsubfx-fx.cpp

1455 lines
42KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2013 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. // -----------------------------------------------------------------------

  29. 

  30. class FxAbstractPlugin : public PluginClass

  31. {

  32. protected:

  33.     FxAbstractPlugin(const HostDescriptor* const host, const uint32_t paramCount, const uint32_t programCount)

  34.         : PluginClass(host),

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

  36.           fProgramCount(programCount),

  37.           fEffect(nullptr),

  38.           efxoutl(nullptr),

  39.           efxoutr(nullptr),

  40.           fFirstInit(true)

  41.     {

  42.         const uint32_t bufferSize(getBufferSize());

  43.         efxoutl = new float[bufferSize];

  44.         efxoutr = new float[bufferSize];

  45.         carla_zeroFloat(efxoutl, bufferSize);

  46.         carla_zeroFloat(efxoutr, bufferSize);

  47.     }

  48. 

  49.     ~FxAbstractPlugin() override

  50.     {

  51.         if (efxoutl != nullptr)

  52.         {

  53.             delete[] efxoutl;

  54.             efxoutl = nullptr;

  55.         }

  56. 

  57.         if (efxoutr != nullptr)

  58.         {

  59.             delete[] efxoutr;

  60.             efxoutr = nullptr;

  61.         }

  62. 

  63.         if (fEffect != nullptr)

  64.         {

  65.             delete fEffect;

  66.             fEffect = nullptr;

  67.         }

  68.     }

  69. 

  70.     // -------------------------------------------------------------------

  71.     // Plugin parameter calls

  72. 

  73.     uint32_t getParameterCount() const final

  74.     {

  75.         return fParamCount;

  76.     }

  77. 

  78.     float getParameterValue(const uint32_t index) const final

  79.     {

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

  81.     }

  82. 

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

  84.     // Plugin midi-program calls

  85. 

  86.     uint32_t getMidiProgramCount() const final

  87.     {

  88.         return fProgramCount;

  89.     }

  90. 

  91.     // -------------------------------------------------------------------

  92.     // Plugin state calls

  93. 

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

  95.     {

  96.         fFirstInit = false;

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

  98.     }

  99. 

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

  101.     {

  102.         fFirstInit = false;

  103.         fEffect->setpreset(program);

  104. 

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

  106.         hostSetVolume(volume);

  107. 

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

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

  110.         hostSetPanning(panning);

  111. 

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

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

  114.     }

  115. 

  116.     // -------------------------------------------------------------------

  117.     // Plugin process calls

  118. 

  119.     void activate() final

  120.     {

  121.         fEffect->cleanup();

  122. 

  123.         if (fFirstInit)

  124.         {

  125.             fFirstInit = false;

  126.             hostSetDryWet(0.5f);

  127.         }

  128.     }

  129. 

  130.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const MidiEvent* const, const uint32_t) final

  131.     {

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

  133. 

  134.         carla_copyFloat(outBuffer[0], efxoutl, frames);

  135.         carla_copyFloat(outBuffer[1], efxoutr, frames);

  136.     }

  137. 

  138.     // -------------------------------------------------------------------

  139.     // Plugin dispatcher

  140. 

  141.     void bufferSizeChanged(const uint32_t bufferSize) final

  142.     {

  143.         delete[] efxoutl;

  144.         delete[] efxoutr;

  145.         efxoutl = new float[bufferSize];

  146.         efxoutr = new float[bufferSize];

  147.         carla_zeroFloat(efxoutl, bufferSize);

  148.         carla_zeroFloat(efxoutr, bufferSize);

  149. 

  150.         doReinit(bufferSize, getSampleRate());

  151.     }

  152. 

  153.     void sampleRateChanged(const double sampleRate) final

  154.     {

  155.         doReinit(getBufferSize(), sampleRate);

  156.     }

  157. 

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

  159.     {

  160.         float params[fParamCount];

  161. 

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

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

  164. 

  165.         reinit(bufferSize, sampleRate);

  166. 

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

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

  169.     }

  170. 

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

  172. 

  173.     // -------------------------------------------------------------------

  174. 

  175.     const uint32_t fParamCount;

  176.     const uint32_t fProgramCount;

  177. 

  178.     Effect* fEffect;

  179.     float*  efxoutl;

  180.     float*  efxoutr;

  181.     bool    fFirstInit;

  182. };

  183. 

  184. // -----------------------------------------------------------------------

  185. 

  186. class FxAlienWahPlugin : public FxAbstractPlugin

  187. {

  188. public:

  189.     FxAlienWahPlugin(const HostDescriptor* const host)

  190.         : FxAbstractPlugin(host, 11, 4)

  191.     {

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

  193.     }

  194. 

  195. protected:

  196.     // -------------------------------------------------------------------

  197.     // Plugin parameter calls

  198. 

  199.     const Parameter* getParameterInfo(const uint32_t index) const override

  200.     {

  201.         if (index >= fParamCount)

  202.             return nullptr;

  203. 

  204.         static Parameter param;

  205.         static ParameterScalePoint scalePoints[2];

  206. 

  207.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  208. 

  209.         param.name = nullptr;

  210.         param.unit = nullptr;

  211.         param.ranges.def       = 1.0f;

  212.         param.ranges.min       = 0.0f;

  213.         param.ranges.max       = 127.0f;

  214.         param.ranges.step      = 1.0f;

  215.         param.ranges.stepSmall = 1.0f;

  216.         param.ranges.stepLarge = 20.0f;

  217.         param.scalePointCount  = 0;

  218.         param.scalePoints      = nullptr;

  219. 

  220.         switch (index)

  221.         {

  222.         case 0:

  223.             hints |= PARAMETER_IS_AUTOMABLE;

  224.             param.name = "LFO Frequency";

  225.             param.ranges.def = 70.0f;

  226.             break;

  227.         case 1:

  228.             hints |= PARAMETER_IS_AUTOMABLE;

  229.             param.name = "LFO Randomness";

  230.             param.ranges.def = 0.0f;

  231.             break;

  232.         case 2:

  233.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  234.             param.name = "LFO Type";

  235.             param.ranges.def = 0.0f;

  236.             param.ranges.max = 1.0f;

  237.             param.scalePointCount = 2;

  238.             param.scalePoints     = scalePoints;

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

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

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

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

  243.             break;

  244.         case 3:

  245.             hints |= PARAMETER_IS_AUTOMABLE;

  246.             param.name = "LFO Stereo";

  247.             param.ranges.def = 62.0f;

  248.             break;

  249.         case 4:

  250.             hints |= PARAMETER_IS_AUTOMABLE;

  251.             param.name = "Depth";

  252.             param.ranges.def = 60.0f;

  253.             break;

  254.         case 5:

  255.             hints |= PARAMETER_IS_AUTOMABLE;

  256.             param.name = "Feedback";

  257.             param.ranges.def = 105.0f;

  258.             break;

  259.         case 6:

  260.             param.name = "Delay";

  261.             param.ranges.def = 25.0f;

  262.             param.ranges.min = 1.0f;

  263.             param.ranges.max = 100.0f;

  264.             break;

  265.         case 7:

  266.             hints |= PARAMETER_IS_AUTOMABLE;

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

  268.             param.ranges.def = 0.0f;

  269.             break;

  270.         case 8:

  271.             hints |= PARAMETER_IS_AUTOMABLE;

  272.             param.name = "Phase";

  273.             param.ranges.def = 64.0f;

  274.             break;

  275.         }

  276. 

  277.         param.hints = static_cast<ParameterHints>(hints);

  278. 

  279.         return &param;

  280.     }

  281. 

  282.     // -------------------------------------------------------------------

  283.     // Plugin midi-program calls

  284. 

  285.     const MidiProgram* getMidiProgramInfo(const uint32_t index) const override

  286.     {

  287.         if (index >= fProgramCount)

  288.             return nullptr;

  289. 

  290.         static MidiProgram midiProg;

  291. 

  292.         midiProg.bank    = 0;

  293.         midiProg.program = index;

  294. 

  295.         switch (index)

  296.         {

  297.         case 0:

  298.             midiProg.name = "AlienWah1";

  299.             break;

  300.         case 1:

  301.             midiProg.name = "AlienWah2";

  302.             break;

  303.         case 2:

  304.             midiProg.name = "AlienWah3";

  305.             break;

  306.         case 3:

  307.             midiProg.name = "AlienWah4";

  308.             break;

  309.         default:

  310.             midiProg.name = nullptr;

  311.             break;

  312.         }

  313. 

  314.         return &midiProg;

  315.     }

  316. 

  317.     // -------------------------------------------------------------------

  318. 

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

  320.     {

  321.         delete fEffect;

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

  323.     }

  324. 

  325.     PluginClassEND(FxAlienWahPlugin)

  326.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  327. };

  328. 

  329. // -----------------------------------------------------------------------

  330. 

  331. class FxChorusPlugin : public FxAbstractPlugin

  332. {

  333. public:

  334.     FxChorusPlugin(const HostDescriptor* const host)

  335.         : FxAbstractPlugin(host, 12, 10)

  336.     {

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

  338.     }

  339. 

  340. protected:

  341.     // -------------------------------------------------------------------

  342.     // Plugin parameter calls

  343. 

  344.     const Parameter* getParameterInfo(const uint32_t index) const override

  345.     {

  346.         if (index >= fParamCount)

  347.             return nullptr;

  348. 

  349.         static Parameter param;

  350.         static ParameterScalePoint scalePoints[2];

  351. 

  352.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  353. 

  354.         param.name = nullptr;

  355.         param.unit = nullptr;

  356.         param.ranges.def       = 1.0f;

  357.         param.ranges.min       = 0.0f;

  358.         param.ranges.max       = 127.0f;

  359.         param.ranges.step      = 1.0f;

  360.         param.ranges.stepSmall = 1.0f;

  361.         param.ranges.stepLarge = 20.0f;

  362.         param.scalePointCount  = 0;

  363.         param.scalePoints      = nullptr;

  364. 

  365.         switch (index)

  366.         {

  367.         case 0:

  368.             hints |= PARAMETER_IS_AUTOMABLE;

  369.             param.name = "LFO Frequency";

  370.             param.ranges.def = 50.0f;

  371.             break;

  372.         case 1:

  373.             hints |= PARAMETER_IS_AUTOMABLE;

  374.             param.name = "LFO Randomness";

  375.             param.ranges.def = 0.0f;

  376.             break;

  377.         case 2:

  378.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  379.             param.name = "LFO Type";

  380.             param.ranges.def = 0.0f;

  381.             param.ranges.max = 1.0f;

  382.             param.scalePointCount = 2;

  383.             param.scalePoints     = scalePoints;

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

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

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

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

  388.             break;

  389.         case 3:

  390.             hints |= PARAMETER_IS_AUTOMABLE;

  391.             param.name = "LFO Stereo";

  392.             param.ranges.def = 90.0f;

  393.             break;

  394.         case 4:

  395.             hints |= PARAMETER_IS_AUTOMABLE;

  396.             param.name = "Depth";

  397.             param.ranges.def = 40.0f;

  398.             break;

  399.         case 5:

  400.             hints |= PARAMETER_IS_AUTOMABLE;

  401.             param.name = "Delay";

  402.             param.ranges.def = 85.0f;

  403.             break;

  404.         case 6:

  405.             hints |= PARAMETER_IS_AUTOMABLE;

  406.             param.name = "Feedback";

  407.             param.ranges.def = 64.0f;

  408.             break;

  409.         case 7:

  410.             hints |= PARAMETER_IS_AUTOMABLE;

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

  412.             param.ranges.def = 119.0f;

  413.             break;

  414.         case 8:

  415.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  416.             param.name = "Flange Mode";

  417.             param.ranges.def = 0.0f;

  418.             param.ranges.max = 1.0f;

  419.             break;

  420.         case 9:

  421.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  422.             param.name = "Subtract Output";

  423.             param.ranges.def = 0.0f;

  424.             param.ranges.max = 1.0f;

  425.             break;

  426.         }

  427. 

  428.         param.hints = static_cast<ParameterHints>(hints);

  429. 

  430.         return &param;

  431.     }

  432. 

  433.     // -------------------------------------------------------------------

  434.     // Plugin midi-program calls

  435. 

  436.     const MidiProgram* getMidiProgramInfo(const uint32_t index) const override

  437.     {

  438.         if (index >= fProgramCount)

  439.             return nullptr;

  440. 

  441.         static MidiProgram midiProg;

  442. 

  443.         midiProg.bank    = 0;

  444.         midiProg.program = index;

  445. 

  446.         switch (index)

  447.         {

  448.         case 0:

  449.             midiProg.name = "Chorus1";

  450.             break;

  451.         case 1:

  452.             midiProg.name = "Chorus2";

  453.             break;

  454.         case 2:

  455.             midiProg.name = "Chorus3";

  456.             break;

  457.         case 3:

  458.             midiProg.name = "Celeste1";

  459.             break;

  460.         case 4:

  461.             midiProg.name = "Celeste2";

  462.             break;

  463.         case 5:

  464.             midiProg.name = "Flange1";

  465.             break;

  466.         case 6:

  467.             midiProg.name = "Flange2";

  468.             break;

  469.         case 7:

  470.             midiProg.name = "Flange3";

  471.             break;

  472.         case 8:

  473.             midiProg.name = "Flange4";

  474.             break;

  475.         case 9:

  476.             midiProg.name = "Flange5";

  477.             break;

  478.         default:

  479.             midiProg.name = nullptr;

  480.             break;

  481.         }

  482. 

  483.         return &midiProg;

  484.     }

  485. 

  486.     // -------------------------------------------------------------------

  487. 

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

  489.     {

  490.         delete fEffect;

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

  492.     }

  493. 

  494.     PluginClassEND(FxChorusPlugin)

  495.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  496. };

  497. 

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

  499. 

  500. class FxDistortionPlugin : public FxAbstractPlugin

  501. {

  502. public:

  503.     FxDistortionPlugin(const HostDescriptor* const host)

  504.         : FxAbstractPlugin(host, 11, 6)

  505.     {

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

  507.     }

  508. 

  509. protected:

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

  511.     // Plugin parameter calls

  512. 

  513.     const Parameter* getParameterInfo(const uint32_t index) const override

  514.     {

  515.         if (index >= fParamCount)

  516.             return nullptr;

  517. 

  518.         static Parameter param;

  519.         static ParameterScalePoint scalePoints[14];

  520. 

  521.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  522. 

  523.         param.name = nullptr;

  524.         param.unit = nullptr;

  525.         param.ranges.def       = 1.0f;

  526.         param.ranges.min       = 0.0f;

  527.         param.ranges.max       = 127.0f;

  528.         param.ranges.step      = 1.0f;

  529.         param.ranges.stepSmall = 1.0f;

  530.         param.ranges.stepLarge = 20.0f;

  531.         param.scalePointCount  = 0;

  532.         param.scalePoints      = nullptr;

  533. 

  534.         switch (index)

  535.         {

  536.         case 0:

  537.             hints |= PARAMETER_IS_AUTOMABLE;

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

  539.             param.ranges.def = 35.0f;

  540.             break;

  541.         case 1:

  542.             hints |= PARAMETER_IS_AUTOMABLE;

  543.             param.name = "Drive";

  544.             param.ranges.def = 56.0f;

  545.             break;

  546.         case 2:

  547.             hints |= PARAMETER_IS_AUTOMABLE;

  548.             param.name = "Level";

  549.             param.ranges.def = 70.0f;

  550.             break;

  551.         case 3:

  552.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_USES_SCALEPOINTS;

  553.             param.name = "Type";

  554.             param.ranges.def = 0.0f;

  555.             param.ranges.max = 13.0f;

  556.             param.scalePointCount = 14;

  557.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  586.             break;

  587.         case 4:

  588.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  589.             param.name = "Negate";

  590.             param.ranges.def = 0.0f;

  591.             param.ranges.max = 1.0f;

  592.             break;

  593.         case 5:

  594.             hints |= PARAMETER_IS_AUTOMABLE;

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

  596.             param.ranges.def = 96.0f;

  597.             break;

  598.         case 6:

  599.             hints |= PARAMETER_IS_AUTOMABLE;

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

  601.             param.ranges.def = 0.0f;

  602.             break;

  603.         case 7:

  604.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  605.             param.name = "Stereo";

  606.             param.ranges.def = 0.0f;

  607.             param.ranges.max = 1.0f;

  608.             break;

  609.         case 8:

  610.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

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

  612.             param.ranges.def = 0.0f;

  613.             param.ranges.max = 1.0f;

  614.             break;

  615.         }

  616. 

  617.         param.hints = static_cast<ParameterHints>(hints);

  618. 

  619.         return &param;

  620.     }

  621. 

  622.     // -------------------------------------------------------------------

  623.     // Plugin midi-program calls

  624. 

  625.     const MidiProgram* getMidiProgramInfo(const uint32_t index) const override

  626.     {

  627.         if (index >= fProgramCount)

  628.             return nullptr;

  629. 

  630.         static MidiProgram midiProg;

  631. 

  632.         midiProg.bank    = 0;

  633.         midiProg.program = index;

  634. 

  635.         switch (index)

  636.         {

  637.         case 0:

  638.             midiProg.name = "Overdrive 1";

  639.             break;

  640.         case 1:

  641.             midiProg.name = "Overdrive 2";

  642.             break;

  643.         case 2:

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

  645.             break;

  646.         case 3:

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

  648.             break;

  649.         case 4:

  650.             midiProg.name = "Guitar Amp";

  651.             break;

  652.         case 5:

  653.             midiProg.name = "Quantisize";

  654.             break;

  655.         default:

  656.             midiProg.name = nullptr;

  657.             break;

  658.         }

  659. 

  660.         return &midiProg;

  661.     }

  662. 

  663.     // -------------------------------------------------------------------

  664. 

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

  666.     {

  667.         delete fEffect;

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

  669.     }

  670. 

  671.     PluginClassEND(FxDistortionPlugin)

  672.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  673. };

  674. 

  675. // -----------------------------------------------------------------------

  676. 

  677. class FxDynamicFilterPlugin : public FxAbstractPlugin

  678. {

  679. public:

  680.     FxDynamicFilterPlugin(const HostDescriptor* const host)

  681.         : FxAbstractPlugin(host, 10, 5)

  682.     {

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

  684.     }

  685. 

  686. protected:

  687.     // -------------------------------------------------------------------

  688.     // Plugin parameter calls

  689. 

  690.     const Parameter* getParameterInfo(const uint32_t index) const override

  691.     {

  692.         if (index >= fParamCount)

  693.             return nullptr;

  694. 

  695.         static Parameter param;

  696.         static ParameterScalePoint scalePoints[2];

  697. 

  698.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  699. 

  700.         param.name = nullptr;

  701.         param.unit = nullptr;

  702.         param.ranges.def       = 1.0f;

  703.         param.ranges.min       = 0.0f;

  704.         param.ranges.max       = 127.0f;

  705.         param.ranges.step      = 1.0f;

  706.         param.ranges.stepSmall = 1.0f;

  707.         param.ranges.stepLarge = 20.0f;

  708.         param.scalePointCount  = 0;

  709.         param.scalePoints      = nullptr;

  710. 

  711.         switch (index)

  712.         {

  713.         case 0:

  714.             hints |= PARAMETER_IS_AUTOMABLE;

  715.             param.name = "LFO Frequency";

  716.             param.ranges.def = 80.0f;

  717.             break;

  718.         case 1:

  719.             hints |= PARAMETER_IS_AUTOMABLE;

  720.             param.name = "LFO Randomness";

  721.             param.ranges.def = 0.0f;

  722.             break;

  723.         case 2:

  724.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  725.             param.name = "LFO Type";

  726.             param.ranges.def = 0.0f;

  727.             param.ranges.max = 1.0f;

  728.             param.scalePointCount = 2;

  729.             param.scalePoints     = scalePoints;

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

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

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

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

  734.             break;

  735.         case 3:

  736.             hints |= PARAMETER_IS_AUTOMABLE;

  737.             param.name = "LFO Stereo";

  738.             param.ranges.def = 64.0f;

  739.             break;

  740.         case 4:

  741.             hints |= PARAMETER_IS_AUTOMABLE;

  742.             param.name = "LFO Depth";

  743.             param.ranges.def = 0.0f;

  744.             break;

  745.         case 5:

  746.             hints |= PARAMETER_IS_AUTOMABLE;

  747.             param.name = "Amp sns";

  748.             param.ranges.def = 90.0f;

  749.             break;

  750.         case 6:

  751.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

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

  753.             param.ranges.def = 0.0f;

  754.             param.ranges.max = 1.0f;

  755.             break;

  756.         case 7:

  757.             hints |= PARAMETER_IS_AUTOMABLE;

  758.             param.name = "Amp Smooth";

  759.             param.ranges.def = 60.0f;

  760.             break;

  761.         }

  762. 

  763.         param.hints = static_cast<ParameterHints>(hints);

  764. 

  765.         return &param;

  766.     }

  767. 

  768.     // -------------------------------------------------------------------

  769.     // Plugin midi-program calls

  770. 

  771.     const MidiProgram* getMidiProgramInfo(const uint32_t index) const override

  772.     {

  773.         if (index >= fProgramCount)

  774.             return nullptr;

  775. 

  776.         static MidiProgram midiProg;

  777. 

  778.         midiProg.bank    = 0;

  779.         midiProg.program = index;

  780. 

  781.         switch (index)

  782.         {

  783.         case 0:

  784.             midiProg.name = "WahWah";

  785.             break;

  786.         case 1:

  787.             midiProg.name = "AutoWah";

  788.             break;

  789.         case 2:

  790.             midiProg.name = "Sweep";

  791.             break;

  792.         case 3:

  793.             midiProg.name = "VocalMorph1";

  794.             break;

  795.         case 4:

  796.             midiProg.name = "VocalMorph2";

  797.             break;

  798.         default:

  799.             midiProg.name = nullptr;

  800.             break;

  801.         }

  802. 

  803.         return &midiProg;

  804.     }

  805. 

  806.     // -------------------------------------------------------------------

  807. 

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

  809.     {

  810.         delete fEffect;

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

  812.     }

  813. 

  814.     PluginClassEND(FxDynamicFilterPlugin)

  815.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  816. };

  817. 

  818. // -----------------------------------------------------------------------

  819. 

  820. class FxEchoPlugin : public FxAbstractPlugin

  821. {

  822. public:

  823.     FxEchoPlugin(const HostDescriptor* const host)

  824.         : FxAbstractPlugin(host, 7, 9)

  825.     {

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

  827.     }

  828. 

  829. protected:

  830.     // -------------------------------------------------------------------

  831.     // Plugin parameter calls

  832. 

  833.     const Parameter* getParameterInfo(const uint32_t index) const override

  834.     {

  835.         if (index >= fParamCount)

  836.             return nullptr;

  837. 

  838.         static Parameter param;

  839. 

  840.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  841. 

  842.         param.name = nullptr;

  843.         param.unit = nullptr;

  844.         param.ranges.def       = 1.0f;

  845.         param.ranges.min       = 0.0f;

  846.         param.ranges.max       = 127.0f;

  847.         param.ranges.step      = 1.0f;

  848.         param.ranges.stepSmall = 1.0f;

  849.         param.ranges.stepLarge = 20.0f;

  850.         param.scalePointCount  = 0;

  851.         param.scalePoints      = nullptr;

  852. 

  853.         switch (index)

  854.         {

  855.         case 0:

  856.             hints |= PARAMETER_IS_AUTOMABLE;

  857.             param.name = "Delay";

  858.             param.ranges.def = 35.0f;

  859.             break;

  860.         case 1:

  861.             hints |= PARAMETER_IS_AUTOMABLE;

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

  863.             param.ranges.def = 64.0f;

  864.             break;

  865.         case 2:

  866.             hints |= PARAMETER_IS_AUTOMABLE;

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

  868.             param.ranges.def = 30.0f;

  869.             break;

  870.         case 3:

  871.             hints |= PARAMETER_IS_AUTOMABLE;

  872.             param.name = "Feedback";

  873.             param.ranges.def = 59.0f;

  874.             break;

  875.         case 4:

  876.             hints |= PARAMETER_IS_AUTOMABLE;

  877.             param.name = "High Damp";

  878.             param.ranges.def = 0.0f;

  879.             break;

  880.         }

  881. 

  882.         param.hints = static_cast<ParameterHints>(hints);

  883. 

  884.         return &param;

  885.     }

  886. 

  887.     // -------------------------------------------------------------------

  888.     // Plugin midi-program calls

  889. 

  890.     const MidiProgram* getMidiProgramInfo(const uint32_t index) const override

  891.     {

  892.         if (index >= fProgramCount)

  893.             return nullptr;

  894. 

  895.         static MidiProgram midiProg;

  896. 

  897.         midiProg.bank    = 0;

  898.         midiProg.program = index;

  899. 

  900.         switch (index)

  901.         {

  902.         case 0:

  903.             midiProg.name = "Echo 1";

  904.             break;

  905.         case 1:

  906.             midiProg.name = "Echo 2";

  907.             break;

  908.         case 2:

  909.             midiProg.name = "Echo 3";

  910.             break;

  911.         case 3:

  912.             midiProg.name = "Simple Echo";

  913.             break;

  914.         case 4:

  915.             midiProg.name = "Canyon";

  916.             break;

  917.         case 5:

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

  919.             break;

  920.         case 6:

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

  922.             break;

  923.         case 7:

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

  925.             break;

  926.         case 8:

  927.             midiProg.name = "Feedback Echo";

  928.             break;

  929.         default:

  930.             midiProg.name = nullptr;

  931.             break;

  932.         }

  933. 

  934.         return &midiProg;

  935.     }

  936. 

  937.     // -------------------------------------------------------------------

  938. 

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

  940.     {

  941.         delete fEffect;

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

  943.     }

  944. 

  945.     PluginClassEND(FxEchoPlugin)

  946.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  947. };

  948. 

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

  950. 

  951. class FxPhaserPlugin : public FxAbstractPlugin

  952. {

  953. public:

  954.     FxPhaserPlugin(const HostDescriptor* const host)

  955.         : FxAbstractPlugin(host, 15, 12)

  956.     {

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

  958.     }

  959. 

  960. protected:

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

  962.     // Plugin parameter calls

  963. 

  964.     const Parameter* getParameterInfo(const uint32_t index) const override

  965.     {

  966.         if (index >= fParamCount)

  967.             return nullptr;

  968. 

  969.         static Parameter param;

  970.         static ParameterScalePoint scalePoints[2];

  971. 

  972.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  973. 

  974.         param.name = nullptr;

  975.         param.unit = nullptr;

  976.         param.ranges.def       = 1.0f;

  977.         param.ranges.min       = 0.0f;

  978.         param.ranges.max       = 127.0f;

  979.         param.ranges.step      = 1.0f;

  980.         param.ranges.stepSmall = 1.0f;

  981.         param.ranges.stepLarge = 20.0f;

  982.         param.scalePointCount  = 0;

  983.         param.scalePoints      = nullptr;

  984. 

  985.         switch (index)

  986.         {

  987.         case 0:

  988.             hints |= PARAMETER_IS_AUTOMABLE;

  989.             param.name = "LFO Frequency";

  990.             param.ranges.def = 36.0f;

  991.             break;

  992.         case 1:

  993.             hints |= PARAMETER_IS_AUTOMABLE;

  994.             param.name = "LFO Randomness";

  995.             param.ranges.def = 0.0f;

  996.             break;

  997.         case 2:

  998.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  999.             param.name = "LFO Type";

  1000.             param.ranges.def = 0.0f;

  1001.             param.ranges.max = 1.0f;

  1002.             param.scalePointCount = 2;

  1003.             param.scalePoints     = scalePoints;

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

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

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

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

  1008.             break;

  1009.         case 3:

  1010.             hints |= PARAMETER_IS_AUTOMABLE;

  1011.             param.name = "LFO Stereo";

  1012.             param.ranges.def = 64.0f;

  1013.             break;

  1014.         case 4:

  1015.             hints |= PARAMETER_IS_AUTOMABLE;

  1016.             param.name = "Depth";

  1017.             param.ranges.def = 110.0f;

  1018.             break;

  1019.         case 5:

  1020.             hints |= PARAMETER_IS_AUTOMABLE;

  1021.             param.name = "Feedback";

  1022.             param.ranges.def = 64.0f;

  1023.             break;

  1024.         case 6:

  1025.             param.name = "Stages";

  1026.             param.ranges.def = 1.0f;

  1027.             param.ranges.min = 1.0f;

  1028.             param.ranges.max = 12.0f;

  1029.             break;

  1030.         case 7:

  1031.             hints |= PARAMETER_IS_AUTOMABLE;

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

  1033.             param.ranges.def = 0.0f;

  1034.             break;

  1035.         case 8:

  1036.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1037.             param.name = "Subtract Output";

  1038.             param.ranges.def = 0.0f;

  1039.             param.ranges.max = 1.0f;

  1040.             break;

  1041.         case 9:

  1042.             hints |= PARAMETER_IS_AUTOMABLE;

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

  1044.             param.ranges.def = 20.0f;

  1045.             break;

  1046.         case 10:

  1047.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1048.             param.name = "Hyper";

  1049.             param.ranges.def = 0.0f;

  1050.             param.ranges.max = 1.0f;

  1051.             break;

  1052.         case 11:

  1053.             hints |= PARAMETER_IS_AUTOMABLE;

  1054.             param.name = "Distortion";

  1055.             param.ranges.def = 0.0f;

  1056.             break;

  1057.         case 12:

  1058.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1059.             param.name = "Analog";

  1060.             param.ranges.def = 0.0f;

  1061.             param.ranges.max = 1.0f;

  1062.             break;

  1063.         }

  1064. 

  1065.         param.hints = static_cast<ParameterHints>(hints);

  1066. 

  1067.         return &param;

  1068.     }

  1069. 

  1070.     // -------------------------------------------------------------------

  1071.     // Plugin midi-program calls

  1072. 

  1073.     const MidiProgram* getMidiProgramInfo(const uint32_t index) const override

  1074.     {

  1075.         if (index >= fProgramCount)

  1076.             return nullptr;

  1077. 

  1078.         static MidiProgram midiProg;

  1079. 

  1080.         midiProg.bank    = 0;

  1081.         midiProg.program = index;

  1082. 

  1083.         switch (index)

  1084.         {

  1085.         case 0:

  1086.             midiProg.name = "Phaser 1";

  1087.             break;

  1088.         case 1:

  1089.             midiProg.name = "Phaser 2";

  1090.             break;

  1091.         case 2:

  1092.             midiProg.name = "Phaser 3";

  1093.             break;

  1094.         case 3:

  1095.             midiProg.name = "Phaser 4";

  1096.             break;

  1097.         case 4:

  1098.             midiProg.name = "Phaser 5";

  1099.             break;

  1100.         case 5:

  1101.             midiProg.name = "Phaser 6";

  1102.             break;

  1103.         case 6:

  1104.             midiProg.name = "APhaser 1";

  1105.             break;

  1106.         case 7:

  1107.             midiProg.name = "APhaser 2";

  1108.             break;

  1109.         case 8:

  1110.             midiProg.name = "APhaser 3";

  1111.             break;

  1112.         case 9:

  1113.             midiProg.name = "APhaser 4";

  1114.             break;

  1115.         case 10:

  1116.             midiProg.name = "APhaser 5";

  1117.             break;

  1118.         case 11:

  1119.             midiProg.name = "APhaser 6";

  1120.             break;

  1121.         default:

  1122.             midiProg.name = nullptr;

  1123.             break;

  1124.         }

  1125. 

  1126.         return &midiProg;

  1127.     }

  1128. 

  1129.     // -------------------------------------------------------------------

  1130. 

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

  1132.     {

  1133.         delete fEffect;

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

  1135.     }

  1136. 

  1137.     PluginClassEND(FxPhaserPlugin)

  1138.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1139. };

  1140. 

  1141. // -----------------------------------------------------------------------

  1142. 

  1143. class FxReverbPlugin : public FxAbstractPlugin

  1144. {

  1145. public:

  1146.     FxReverbPlugin(const HostDescriptor* const host)

  1147.         : FxAbstractPlugin(host, 13, 13)

  1148.     {

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

  1150.     }

  1151. 

  1152. protected:

  1153.     // -------------------------------------------------------------------

  1154.     // Plugin parameter calls

  1155. 

  1156.     const Parameter* getParameterInfo(const uint32_t index) const override

  1157.     {

  1158.         if (index >= fParamCount)

  1159.             return nullptr;

  1160. 

  1161.         static Parameter param;

  1162.         static ParameterScalePoint scalePoints[3];

  1163. 

  1164.         int hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;

  1165. 

  1166.         param.name = nullptr;

  1167.         param.unit = nullptr;

  1168.         param.ranges.def       = 1.0f;

  1169.         param.ranges.min       = 0.0f;

  1170.         param.ranges.max       = 127.0f;

  1171.         param.ranges.step      = 1.0f;

  1172.         param.ranges.stepSmall = 1.0f;

  1173.         param.ranges.stepLarge = 20.0f;

  1174.         param.scalePointCount  = 0;

  1175.         param.scalePoints      = nullptr;

  1176. 

  1177.         switch (index)

  1178.         {

  1179.         case 0:

  1180.             hints |= PARAMETER_IS_AUTOMABLE;

  1181.             param.name = "Time";

  1182.             param.ranges.def = 63.0f;

  1183.             break;

  1184.         case 1:

  1185.             param.name = "Delay";

  1186.             param.ranges.def = 24.0f;

  1187.             break;

  1188.         case 2:

  1189.             hints |= PARAMETER_IS_AUTOMABLE;

  1190.             param.name = "Feedback";

  1191.             param.ranges.def = 0.0f;

  1192.             break;

  1193.         case 3:

  1194.             hints = 0x0;

  1195.             param.name = "bw";

  1196.             break;

  1197.         case 4:

  1198.             hints = 0x0;

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

  1200.             break;

  1201.         case 5:

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

  1203.             param.ranges.def = 85.0f;

  1204.             break;

  1205.         case 6:

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

  1207.             param.ranges.def = 5.0f;

  1208.             break;

  1209.         case 7:

  1210.             hints |= PARAMETER_IS_AUTOMABLE;

  1211.             param.name = "Damp";

  1212.             param.ranges.def = 83.0f;

  1213.             param.ranges.min = 64.0f;

  1214.             break;

  1215.         case 8:

  1216.             hints |= PARAMETER_USES_SCALEPOINTS;

  1217.             param.name = "Type";

  1218.             param.ranges.def = 1.0f;

  1219.             param.ranges.max = 2.0f;

  1220.             param.scalePointCount = 3;

  1221.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1228.             break;

  1229.         case 9:

  1230.             param.name = "Room size";

  1231.             param.ranges.def = 64.0f;

  1232.             param.ranges.min = 1.0f;

  1233.             break;

  1234.         case 10:

  1235.             param.name = "Bandwidth";

  1236.             param.ranges.def = 20.0f;

  1237.             break;

  1238.         }

  1239. 

  1240.         param.hints = static_cast<ParameterHints>(hints);

  1241. 

  1242.         return &param;

  1243.     }

  1244. 

  1245.     // -------------------------------------------------------------------

  1246.     // Plugin midi-program calls

  1247. 

  1248.     const MidiProgram* getMidiProgramInfo(const uint32_t index) const override

  1249.     {

  1250.         if (index >= fProgramCount)

  1251.             return nullptr;

  1252. 

  1253.         static MidiProgram midiProg;

  1254. 

  1255.         midiProg.bank    = 0;

  1256.         midiProg.program = index;

  1257. 

  1258.         switch (index)

  1259.         {

  1260.         case 0:

  1261.             midiProg.name = "Cathedral1";

  1262.             break;

  1263.         case 1:

  1264.             midiProg.name = "Cathedral2";

  1265.             break;

  1266.         case 2:

  1267.             midiProg.name = "Cathedral3";

  1268.             break;

  1269.         case 3:

  1270.             midiProg.name = "Hall1";

  1271.             break;

  1272.         case 4:

  1273.             midiProg.name = "Hall2";

  1274.             break;

  1275.         case 5:

  1276.             midiProg.name = "Room1";

  1277.             break;

  1278.         case 6:

  1279.             midiProg.name = "Room2";

  1280.             break;

  1281.         case 7:

  1282.             midiProg.name = "Basement";

  1283.             break;

  1284.         case 8:

  1285.             midiProg.name = "Tunnel";

  1286.             break;

  1287.         case 9:

  1288.             midiProg.name = "Echoed1";

  1289.             break;

  1290.         case 10:

  1291.             midiProg.name = "Echoed2";

  1292.             break;

  1293.         case 11:

  1294.             midiProg.name = "VeryLong1";

  1295.             break;

  1296.         case 12:

  1297.             midiProg.name = "VeryLong2";

  1298.             break;

  1299.         default:

  1300.             midiProg.name = nullptr;

  1301.             break;

  1302.         }

  1303. 

  1304.         return &midiProg;

  1305.     }

  1306. 

  1307.     // -------------------------------------------------------------------

  1308. 

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

  1310.     {

  1311.         delete fEffect;

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

  1313.     }

  1314. 

  1315.     PluginClassEND(FxReverbPlugin)

  1316.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1317. };

  1318. 

  1319. // -----------------------------------------------------------------------

  1320. 

  1321. static const PluginDescriptor fxAlienWahDesc = {

  1322.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  1323.     /* hints     */ static_cast<PluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

  1324.     /* supports  */ static_cast<PluginSupports>(0x0),

  1325.     /* audioIns  */ 2,

  1326.     /* audioOuts */ 2,

  1327.     /* midiIns   */ 0,

  1328.     /* midiOuts  */ 0,

  1329.     /* paramIns  */ 11-2,

  1330.     /* paramOuts */ 0,

  1331.     /* name      */ "ZynAlienWah",

  1332.     /* label     */ "zynAlienWah",

  1333.     /* maker     */ "falkTX",

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

  1335.     PluginDescriptorFILL(FxAlienWahPlugin)

  1336. };

  1337. 

  1338. static const PluginDescriptor fxChorusDesc = {

  1339.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  1340.     /* hints     */ static_cast<PluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

  1341.     /* supports  */ static_cast<PluginSupports>(0x0),

  1342.     /* audioIns  */ 2,

  1343.     /* audioOuts */ 2,

  1344.     /* midiIns   */ 0,

  1345.     /* midiOuts  */ 0,

  1346.     /* paramIns  */ 12-2,

  1347.     /* paramOuts */ 0,

  1348.     /* name      */ "ZynChorus",

  1349.     /* label     */ "zynChorus",

  1350.     /* maker     */ "falkTX",

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

  1352.     PluginDescriptorFILL(FxChorusPlugin)

  1353. };

  1354. 

  1355. static const PluginDescriptor fxDistortionDesc = {

  1356.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  1357.     /* hints     */ static_cast<PluginHints>(PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

  1358.     /* supports  */ static_cast<PluginSupports>(0x0),

  1359.     /* audioIns  */ 2,

  1360.     /* audioOuts */ 2,

  1361.     /* midiIns   */ 0,

  1362.     /* midiOuts  */ 0,

  1363.     /* paramIns  */ 11-2,

  1364.     /* paramOuts */ 0,

  1365.     /* name      */ "ZynDistortion",

  1366.     /* label     */ "zynDistortion",

  1367.     /* maker     */ "falkTX",

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

  1369.     PluginDescriptorFILL(FxDistortionPlugin)

  1370. };

  1371. 

  1372. static const PluginDescriptor fxDynamicFilterDesc = {

  1373.     /* category  */ PLUGIN_CATEGORY_FILTER,

  1374.     /* hints     */ static_cast<PluginHints>(PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

  1375.     /* supports  */ static_cast<PluginSupports>(0x0),

  1376.     /* audioIns  */ 2,

  1377.     /* audioOuts */ 2,

  1378.     /* midiIns   */ 0,

  1379.     /* midiOuts  */ 0,

  1380.     /* paramIns  */ 10-2,

  1381.     /* paramOuts */ 0,

  1382.     /* name      */ "ZynDynamicFilter",

  1383.     /* label     */ "zynDynamicFilter",

  1384.     /* maker     */ "falkTX",

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

  1386.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1387. };

  1388. 

  1389. static const PluginDescriptor fxEchoDesc = {

  1390.     /* category  */ PLUGIN_CATEGORY_DELAY,

  1391.     /* hints     */ static_cast<PluginHints>(PLUGIN_IS_RTSAFE|PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

  1392.     /* supports  */ static_cast<PluginSupports>(0x0),

  1393.     /* audioIns  */ 2,

  1394.     /* audioOuts */ 2,

  1395.     /* midiIns   */ 0,

  1396.     /* midiOuts  */ 0,

  1397.     /* paramIns  */ 7-2,

  1398.     /* paramOuts */ 0,

  1399.     /* name      */ "ZynEcho",

  1400.     /* label     */ "zynEcho",

  1401.     /* maker     */ "falkTX",

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

  1403.     PluginDescriptorFILL(FxEchoPlugin)

  1404. };

  1405. 

  1406. static const PluginDescriptor fxPhaserDesc = {

  1407.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

  1408.     /* hints     */ static_cast<PluginHints>(PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

  1409.     /* supports  */ static_cast<PluginSupports>(0x0),

  1410.     /* audioIns  */ 2,

  1411.     /* audioOuts */ 2,

  1412.     /* midiIns   */ 0,

  1413.     /* midiOuts  */ 0,

  1414.     /* paramIns  */ 15-2,

  1415.     /* paramOuts */ 0,

  1416.     /* name      */ "ZynPhaser",

  1417.     /* label     */ "zynPhaser",

  1418.     /* maker     */ "falkTX",

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

  1420.     PluginDescriptorFILL(FxPhaserPlugin)

  1421. };

  1422. 

  1423. static const PluginDescriptor fxReverbDesc = {

  1424.     /* category  */ PLUGIN_CATEGORY_DELAY,

  1425.     /* hints     */ static_cast<PluginHints>(PLUGIN_USES_PANNING|PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1427.     /* audioIns  */ 2,

  1428.     /* audioOuts */ 2,

  1429.     /* midiIns   */ 0,

  1430.     /* midiOuts  */ 0,

  1431.     /* paramIns  */ 13-2,

  1432.     /* paramOuts */ 0,

  1433.     /* name      */ "ZynReverb",

  1434.     /* label     */ "zynReverb",

  1435.     /* maker     */ "falkTX",

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

  1437.     PluginDescriptorFILL(FxReverbPlugin)

  1438. };

  1439. 

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

  1441. 

  1442. CARLA_EXPORT

  1443. void carla_register_native_plugin_zynaddsubfx_fx()

  1444. {

  1445.     carla_register_native_plugin(&fxAlienWahDesc);

  1446.     carla_register_native_plugin(&fxChorusDesc);

  1447.     carla_register_native_plugin(&fxDistortionDesc);

  1448.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1449.     carla_register_native_plugin(&fxEchoDesc);

  1450.     carla_register_native_plugin(&fxPhaserDesc);

  1451.     carla_register_native_plugin(&fxReverbDesc);

  1452. }

  1453. 

  1454. // -----------------------------------------------------------------------