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

1468 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. #ifdef HAVE_JUCE

  29. # include "juce_audio_basics.h"

  30. using juce::FloatVectorOperations;

  31. #endif

  32. 

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

  34. 

  35. class FxAbstractPlugin : public NativePluginClass

  36. {

  37. protected:

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

  39.         : NativePluginClass(host),

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

  41.           fProgramCount(programCount),

  42.           fEffect(nullptr),

  43.           efxoutl(nullptr),

  44.           efxoutr(nullptr),

  45.           fFirstInit(true)

  46.     {

  47.         const uint32_t bufferSize(getBufferSize());

  48.         efxoutl = new float[bufferSize];

  49.         efxoutr = new float[bufferSize];

  50. #ifdef HAVE_JUCE

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

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

  53. #else

  54. #endif

  55.     }

  56. 

  57.     ~FxAbstractPlugin() override

  58.     {

  59.         if (efxoutl != nullptr)

  60.         {

  61.             delete[] efxoutl;

  62.             efxoutl = nullptr;

  63.         }

  64. 

  65.         if (efxoutr != nullptr)

  66.         {

  67.             delete[] efxoutr;

  68.             efxoutr = nullptr;

  69.         }

  70. 

  71.         if (fEffect != nullptr)

  72.         {

  73.             delete fEffect;

  74.             fEffect = nullptr;

  75.         }

  76.     }

  77. 

  78.     // -------------------------------------------------------------------

  79.     // Plugin parameter calls

  80. 

  81.     uint32_t getParameterCount() const final

  82.     {

  83.         return fParamCount;

  84.     }

  85. 

  86.     float getParameterValue(const uint32_t index) const final

  87.     {

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

  89.     }

  90. 

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

  92.     // Plugin midi-program calls

  93. 

  94.     uint32_t getMidiProgramCount() const final

  95.     {

  96.         return fProgramCount;

  97.     }

  98. 

  99.     // -------------------------------------------------------------------

  100.     // Plugin state calls

  101. 

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

  103.     {

  104.         fFirstInit = false;

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

  106.     }

  107. 

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

  109.     {

  110.         fFirstInit = false;

  111.         fEffect->setpreset(program);

  112. 

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

  114.         hostSetVolume(volume);

  115. 

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

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

  118.         hostSetPanning(panning);

  119. 

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

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

  122.     }

  123. 

  124.     // -------------------------------------------------------------------

  125.     // Plugin process calls

  126. 

  127.     void activate() final

  128.     {

  129.         fEffect->cleanup();

  130. 

  131.         if (fFirstInit)

  132.         {

  133.             fFirstInit = false;

  134.             hostSetDryWet(0.5f);

  135.         }

  136.     }

  137. 

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

  139.     {

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

  141. 

  142. #ifdef HAVE_JUCE

  143.         FloatVectorOperations::copy(outBuffer[0], efxoutl, frames);

  144.         FloatVectorOperations::copy(outBuffer[1], efxoutr, frames);

  145. #else

  146. #endif

  147.     }

  148. 

  149.     // -------------------------------------------------------------------

  150.     // Plugin dispatcher

  151. 

  152.     void bufferSizeChanged(const uint32_t bufferSize) final

  153.     {

  154.         delete[] efxoutl;

  155.         delete[] efxoutr;

  156.         efxoutl = new float[bufferSize];

  157.         efxoutr = new float[bufferSize];

  158. #ifdef HAVE_JUCE

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

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

  161. #else

  162. #endif

  163.         doReinit(bufferSize, getSampleRate());

  164.     }

  165. 

  166.     void sampleRateChanged(const double sampleRate) final

  167.     {

  168.         doReinit(getBufferSize(), sampleRate);

  169.     }

  170. 

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

  172.     {

  173.         float params[fParamCount];

  174. 

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

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

  177. 

  178.         reinit(bufferSize, sampleRate);

  179. 

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

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

  182.     }

  183. 

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

  185. 

  186.     // -------------------------------------------------------------------

  187. 

  188.     const uint32_t fParamCount;

  189.     const uint32_t fProgramCount;

  190. 

  191.     Effect* fEffect;

  192.     float*  efxoutl;

  193.     float*  efxoutr;

  194.     bool    fFirstInit;

  195. };

  196. 

  197. // -----------------------------------------------------------------------

  198. 

  199. class FxAlienWahPlugin : public FxAbstractPlugin

  200. {

  201. public:

  202.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

  203.         : FxAbstractPlugin(host, 11, 4)

  204.     {

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

  206.     }

  207. 

  208. protected:

  209.     // -------------------------------------------------------------------

  210.     // Plugin parameter calls

  211. 

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

  213.     {

  214.         if (index >= fParamCount)

  215.             return nullptr;

  216. 

  217.         static NativeParameter param;

  218.         static NativeParameterScalePoint scalePoints[2];

  219. 

  220.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  221. 

  222.         param.name = nullptr;

  223.         param.unit = nullptr;

  224.         param.ranges.def       = 1.0f;

  225.         param.ranges.min       = 0.0f;

  226.         param.ranges.max       = 127.0f;

  227.         param.ranges.step      = 1.0f;

  228.         param.ranges.stepSmall = 1.0f;

  229.         param.ranges.stepLarge = 20.0f;

  230.         param.scalePointCount  = 0;

  231.         param.scalePoints      = nullptr;

  232. 

  233.         switch (index)

  234.         {

  235.         case 0:

  236.             hints |= PARAMETER_IS_AUTOMABLE;

  237.             param.name = "LFO Frequency";

  238.             param.ranges.def = 70.0f;

  239.             break;

  240.         case 1:

  241.             hints |= PARAMETER_IS_AUTOMABLE;

  242.             param.name = "LFO Randomness";

  243.             param.ranges.def = 0.0f;

  244.             break;

  245.         case 2:

  246.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  247.             param.name = "LFO Type";

  248.             param.ranges.def = 0.0f;

  249.             param.ranges.max = 1.0f;

  250.             param.scalePointCount = 2;

  251.             param.scalePoints     = scalePoints;

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

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

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

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

  256.             break;

  257.         case 3:

  258.             hints |= PARAMETER_IS_AUTOMABLE;

  259.             param.name = "LFO Stereo";

  260.             param.ranges.def = 62.0f;

  261.             break;

  262.         case 4:

  263.             hints |= PARAMETER_IS_AUTOMABLE;

  264.             param.name = "Depth";

  265.             param.ranges.def = 60.0f;

  266.             break;

  267.         case 5:

  268.             hints |= PARAMETER_IS_AUTOMABLE;

  269.             param.name = "Feedback";

  270.             param.ranges.def = 105.0f;

  271.             break;

  272.         case 6:

  273.             param.name = "Delay";

  274.             param.ranges.def = 25.0f;

  275.             param.ranges.min = 1.0f;

  276.             param.ranges.max = 100.0f;

  277.             break;

  278.         case 7:

  279.             hints |= PARAMETER_IS_AUTOMABLE;

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

  281.             param.ranges.def = 0.0f;

  282.             break;

  283.         case 8:

  284.             hints |= PARAMETER_IS_AUTOMABLE;

  285.             param.name = "Phase";

  286.             param.ranges.def = 64.0f;

  287.             break;

  288.         }

  289. 

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

  291. 

  292.         return &param;

  293.     }

  294. 

  295.     // -------------------------------------------------------------------

  296.     // Plugin midi-program calls

  297. 

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

  299.     {

  300.         if (index >= fProgramCount)

  301.             return nullptr;

  302. 

  303.         static NativeMidiProgram midiProg;

  304. 

  305.         midiProg.bank    = 0;

  306.         midiProg.program = index;

  307. 

  308.         switch (index)

  309.         {

  310.         case 0:

  311.             midiProg.name = "AlienWah1";

  312.             break;

  313.         case 1:

  314.             midiProg.name = "AlienWah2";

  315.             break;

  316.         case 2:

  317.             midiProg.name = "AlienWah3";

  318.             break;

  319.         case 3:

  320.             midiProg.name = "AlienWah4";

  321.             break;

  322.         default:

  323.             midiProg.name = nullptr;

  324.             break;

  325.         }

  326. 

  327.         return &midiProg;

  328.     }

  329. 

  330.     // -------------------------------------------------------------------

  331. 

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

  333.     {

  334.         delete fEffect;

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

  336.     }

  337. 

  338.     PluginClassEND(FxAlienWahPlugin)

  339.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  340. };

  341. 

  342. // -----------------------------------------------------------------------

  343. 

  344. class FxChorusPlugin : public FxAbstractPlugin

  345. {

  346. public:

  347.     FxChorusPlugin(const NativeHostDescriptor* const host)

  348.         : FxAbstractPlugin(host, 12, 10)

  349.     {

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

  351.     }

  352. 

  353. protected:

  354.     // -------------------------------------------------------------------

  355.     // Plugin parameter calls

  356. 

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

  358.     {

  359.         if (index >= fParamCount)

  360.             return nullptr;

  361. 

  362.         static NativeParameter param;

  363.         static NativeParameterScalePoint scalePoints[2];

  364. 

  365.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  366. 

  367.         param.name = nullptr;

  368.         param.unit = nullptr;

  369.         param.ranges.def       = 1.0f;

  370.         param.ranges.min       = 0.0f;

  371.         param.ranges.max       = 127.0f;

  372.         param.ranges.step      = 1.0f;

  373.         param.ranges.stepSmall = 1.0f;

  374.         param.ranges.stepLarge = 20.0f;

  375.         param.scalePointCount  = 0;

  376.         param.scalePoints      = nullptr;

  377. 

  378.         switch (index)

  379.         {

  380.         case 0:

  381.             hints |= PARAMETER_IS_AUTOMABLE;

  382.             param.name = "LFO Frequency";

  383.             param.ranges.def = 50.0f;

  384.             break;

  385.         case 1:

  386.             hints |= PARAMETER_IS_AUTOMABLE;

  387.             param.name = "LFO Randomness";

  388.             param.ranges.def = 0.0f;

  389.             break;

  390.         case 2:

  391.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  392.             param.name = "LFO Type";

  393.             param.ranges.def = 0.0f;

  394.             param.ranges.max = 1.0f;

  395.             param.scalePointCount = 2;

  396.             param.scalePoints     = scalePoints;

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

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

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

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

  401.             break;

  402.         case 3:

  403.             hints |= PARAMETER_IS_AUTOMABLE;

  404.             param.name = "LFO Stereo";

  405.             param.ranges.def = 90.0f;

  406.             break;

  407.         case 4:

  408.             hints |= PARAMETER_IS_AUTOMABLE;

  409.             param.name = "Depth";

  410.             param.ranges.def = 40.0f;

  411.             break;

  412.         case 5:

  413.             hints |= PARAMETER_IS_AUTOMABLE;

  414.             param.name = "Delay";

  415.             param.ranges.def = 85.0f;

  416.             break;

  417.         case 6:

  418.             hints |= PARAMETER_IS_AUTOMABLE;

  419.             param.name = "Feedback";

  420.             param.ranges.def = 64.0f;

  421.             break;

  422.         case 7:

  423.             hints |= PARAMETER_IS_AUTOMABLE;

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

  425.             param.ranges.def = 119.0f;

  426.             break;

  427.         case 8:

  428.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  429.             param.name = "Flange Mode";

  430.             param.ranges.def = 0.0f;

  431.             param.ranges.max = 1.0f;

  432.             break;

  433.         case 9:

  434.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  435.             param.name = "Subtract Output";

  436.             param.ranges.def = 0.0f;

  437.             param.ranges.max = 1.0f;

  438.             break;

  439.         }

  440. 

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

  442. 

  443.         return &param;

  444.     }

  445. 

  446.     // -------------------------------------------------------------------

  447.     // Plugin midi-program calls

  448. 

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

  450.     {

  451.         if (index >= fProgramCount)

  452.             return nullptr;

  453. 

  454.         static NativeMidiProgram midiProg;

  455. 

  456.         midiProg.bank    = 0;

  457.         midiProg.program = index;

  458. 

  459.         switch (index)

  460.         {

  461.         case 0:

  462.             midiProg.name = "Chorus1";

  463.             break;

  464.         case 1:

  465.             midiProg.name = "Chorus2";

  466.             break;

  467.         case 2:

  468.             midiProg.name = "Chorus3";

  469.             break;

  470.         case 3:

  471.             midiProg.name = "Celeste1";

  472.             break;

  473.         case 4:

  474.             midiProg.name = "Celeste2";

  475.             break;

  476.         case 5:

  477.             midiProg.name = "Flange1";

  478.             break;

  479.         case 6:

  480.             midiProg.name = "Flange2";

  481.             break;

  482.         case 7:

  483.             midiProg.name = "Flange3";

  484.             break;

  485.         case 8:

  486.             midiProg.name = "Flange4";

  487.             break;

  488.         case 9:

  489.             midiProg.name = "Flange5";

  490.             break;

  491.         default:

  492.             midiProg.name = nullptr;

  493.             break;

  494.         }

  495. 

  496.         return &midiProg;

  497.     }

  498. 

  499.     // -------------------------------------------------------------------

  500. 

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

  502.     {

  503.         delete fEffect;

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

  505.     }

  506. 

  507.     PluginClassEND(FxChorusPlugin)

  508.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  509. };

  510. 

  511. // -----------------------------------------------------------------------

  512. 

  513. class FxDistortionPlugin : public FxAbstractPlugin

  514. {

  515. public:

  516.     FxDistortionPlugin(const NativeHostDescriptor* const host)

  517.         : FxAbstractPlugin(host, 11, 6)

  518.     {

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

  520.     }

  521. 

  522. protected:

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

  524.     // Plugin parameter calls

  525. 

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

  527.     {

  528.         if (index >= fParamCount)

  529.             return nullptr;

  530. 

  531.         static NativeParameter param;

  532.         static NativeParameterScalePoint scalePoints[14];

  533. 

  534.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  535. 

  536.         param.name = nullptr;

  537.         param.unit = nullptr;

  538.         param.ranges.def       = 1.0f;

  539.         param.ranges.min       = 0.0f;

  540.         param.ranges.max       = 127.0f;

  541.         param.ranges.step      = 1.0f;

  542.         param.ranges.stepSmall = 1.0f;

  543.         param.ranges.stepLarge = 20.0f;

  544.         param.scalePointCount  = 0;

  545.         param.scalePoints      = nullptr;

  546. 

  547.         switch (index)

  548.         {

  549.         case 0:

  550.             hints |= PARAMETER_IS_AUTOMABLE;

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

  552.             param.ranges.def = 35.0f;

  553.             break;

  554.         case 1:

  555.             hints |= PARAMETER_IS_AUTOMABLE;

  556.             param.name = "Drive";

  557.             param.ranges.def = 56.0f;

  558.             break;

  559.         case 2:

  560.             hints |= PARAMETER_IS_AUTOMABLE;

  561.             param.name = "Level";

  562.             param.ranges.def = 70.0f;

  563.             break;

  564.         case 3:

  565.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_USES_SCALEPOINTS;

  566.             param.name = "Type";

  567.             param.ranges.def = 0.0f;

  568.             param.ranges.max = 13.0f;

  569.             param.scalePointCount = 14;

  570.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  599.             break;

  600.         case 4:

  601.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  602.             param.name = "Negate";

  603.             param.ranges.def = 0.0f;

  604.             param.ranges.max = 1.0f;

  605.             break;

  606.         case 5:

  607.             hints |= PARAMETER_IS_AUTOMABLE;

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

  609.             param.ranges.def = 96.0f;

  610.             break;

  611.         case 6:

  612.             hints |= PARAMETER_IS_AUTOMABLE;

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

  614.             param.ranges.def = 0.0f;

  615.             break;

  616.         case 7:

  617.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  618.             param.name = "Stereo";

  619.             param.ranges.def = 0.0f;

  620.             param.ranges.max = 1.0f;

  621.             break;

  622.         case 8:

  623.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

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

  625.             param.ranges.def = 0.0f;

  626.             param.ranges.max = 1.0f;

  627.             break;

  628.         }

  629. 

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

  631. 

  632.         return &param;

  633.     }

  634. 

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

  636.     // Plugin midi-program calls

  637. 

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

  639.     {

  640.         if (index >= fProgramCount)

  641.             return nullptr;

  642. 

  643.         static NativeMidiProgram midiProg;

  644. 

  645.         midiProg.bank    = 0;

  646.         midiProg.program = index;

  647. 

  648.         switch (index)

  649.         {

  650.         case 0:

  651.             midiProg.name = "Overdrive 1";

  652.             break;

  653.         case 1:

  654.             midiProg.name = "Overdrive 2";

  655.             break;

  656.         case 2:

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

  658.             break;

  659.         case 3:

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

  661.             break;

  662.         case 4:

  663.             midiProg.name = "Guitar Amp";

  664.             break;

  665.         case 5:

  666.             midiProg.name = "Quantisize";

  667.             break;

  668.         default:

  669.             midiProg.name = nullptr;

  670.             break;

  671.         }

  672. 

  673.         return &midiProg;

  674.     }

  675. 

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

  677. 

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

  679.     {

  680.         delete fEffect;

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

  682.     }

  683. 

  684.     PluginClassEND(FxDistortionPlugin)

  685.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  686. };

  687. 

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

  689. 

  690. class FxDynamicFilterPlugin : public FxAbstractPlugin

  691. {

  692. public:

  693.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

  694.         : FxAbstractPlugin(host, 10, 5)

  695.     {

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

  697.     }

  698. 

  699. protected:

  700.     // -------------------------------------------------------------------

  701.     // Plugin parameter calls

  702. 

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

  704.     {

  705.         if (index >= fParamCount)

  706.             return nullptr;

  707. 

  708.         static NativeParameter param;

  709.         static NativeParameterScalePoint scalePoints[2];

  710. 

  711.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  712. 

  713.         param.name = nullptr;

  714.         param.unit = nullptr;

  715.         param.ranges.def       = 1.0f;

  716.         param.ranges.min       = 0.0f;

  717.         param.ranges.max       = 127.0f;

  718.         param.ranges.step      = 1.0f;

  719.         param.ranges.stepSmall = 1.0f;

  720.         param.ranges.stepLarge = 20.0f;

  721.         param.scalePointCount  = 0;

  722.         param.scalePoints      = nullptr;

  723. 

  724.         switch (index)

  725.         {

  726.         case 0:

  727.             hints |= PARAMETER_IS_AUTOMABLE;

  728.             param.name = "LFO Frequency";

  729.             param.ranges.def = 80.0f;

  730.             break;

  731.         case 1:

  732.             hints |= PARAMETER_IS_AUTOMABLE;

  733.             param.name = "LFO Randomness";

  734.             param.ranges.def = 0.0f;

  735.             break;

  736.         case 2:

  737.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  738.             param.name = "LFO Type";

  739.             param.ranges.def = 0.0f;

  740.             param.ranges.max = 1.0f;

  741.             param.scalePointCount = 2;

  742.             param.scalePoints     = scalePoints;

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

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

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

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

  747.             break;

  748.         case 3:

  749.             hints |= PARAMETER_IS_AUTOMABLE;

  750.             param.name = "LFO Stereo";

  751.             param.ranges.def = 64.0f;

  752.             break;

  753.         case 4:

  754.             hints |= PARAMETER_IS_AUTOMABLE;

  755.             param.name = "LFO Depth";

  756.             param.ranges.def = 0.0f;

  757.             break;

  758.         case 5:

  759.             hints |= PARAMETER_IS_AUTOMABLE;

  760.             param.name = "Amp sns";

  761.             param.ranges.def = 90.0f;

  762.             break;

  763.         case 6:

  764.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

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

  766.             param.ranges.def = 0.0f;

  767.             param.ranges.max = 1.0f;

  768.             break;

  769.         case 7:

  770.             hints |= PARAMETER_IS_AUTOMABLE;

  771.             param.name = "Amp Smooth";

  772.             param.ranges.def = 60.0f;

  773.             break;

  774.         }

  775. 

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

  777. 

  778.         return &param;

  779.     }

  780. 

  781.     // -------------------------------------------------------------------

  782.     // Plugin midi-program calls

  783. 

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

  785.     {

  786.         if (index >= fProgramCount)

  787.             return nullptr;

  788. 

  789.         static NativeMidiProgram midiProg;

  790. 

  791.         midiProg.bank    = 0;

  792.         midiProg.program = index;

  793. 

  794.         switch (index)

  795.         {

  796.         case 0:

  797.             midiProg.name = "WahWah";

  798.             break;

  799.         case 1:

  800.             midiProg.name = "AutoWah";

  801.             break;

  802.         case 2:

  803.             midiProg.name = "Sweep";

  804.             break;

  805.         case 3:

  806.             midiProg.name = "VocalMorph1";

  807.             break;

  808.         case 4:

  809.             midiProg.name = "VocalMorph2";

  810.             break;

  811.         default:

  812.             midiProg.name = nullptr;

  813.             break;

  814.         }

  815. 

  816.         return &midiProg;

  817.     }

  818. 

  819.     // -------------------------------------------------------------------

  820. 

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

  822.     {

  823.         delete fEffect;

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

  825.     }

  826. 

  827.     PluginClassEND(FxDynamicFilterPlugin)

  828.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  829. };

  830. 

  831. // -----------------------------------------------------------------------

  832. 

  833. class FxEchoPlugin : public FxAbstractPlugin

  834. {

  835. public:

  836.     FxEchoPlugin(const NativeHostDescriptor* const host)

  837.         : FxAbstractPlugin(host, 7, 9)

  838.     {

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

  840.     }

  841. 

  842. protected:

  843.     // -------------------------------------------------------------------

  844.     // Plugin parameter calls

  845. 

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

  847.     {

  848.         if (index >= fParamCount)

  849.             return nullptr;

  850. 

  851.         static NativeParameter param;

  852. 

  853.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  854. 

  855.         param.name = nullptr;

  856.         param.unit = nullptr;

  857.         param.ranges.def       = 1.0f;

  858.         param.ranges.min       = 0.0f;

  859.         param.ranges.max       = 127.0f;

  860.         param.ranges.step      = 1.0f;

  861.         param.ranges.stepSmall = 1.0f;

  862.         param.ranges.stepLarge = 20.0f;

  863.         param.scalePointCount  = 0;

  864.         param.scalePoints      = nullptr;

  865. 

  866.         switch (index)

  867.         {

  868.         case 0:

  869.             hints |= PARAMETER_IS_AUTOMABLE;

  870.             param.name = "Delay";

  871.             param.ranges.def = 35.0f;

  872.             break;

  873.         case 1:

  874.             hints |= PARAMETER_IS_AUTOMABLE;

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

  876.             param.ranges.def = 64.0f;

  877.             break;

  878.         case 2:

  879.             hints |= PARAMETER_IS_AUTOMABLE;

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

  881.             param.ranges.def = 30.0f;

  882.             break;

  883.         case 3:

  884.             hints |= PARAMETER_IS_AUTOMABLE;

  885.             param.name = "Feedback";

  886.             param.ranges.def = 59.0f;

  887.             break;

  888.         case 4:

  889.             hints |= PARAMETER_IS_AUTOMABLE;

  890.             param.name = "High Damp";

  891.             param.ranges.def = 0.0f;

  892.             break;

  893.         }

  894. 

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

  896. 

  897.         return &param;

  898.     }

  899. 

  900.     // -------------------------------------------------------------------

  901.     // Plugin midi-program calls

  902. 

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

  904.     {

  905.         if (index >= fProgramCount)

  906.             return nullptr;

  907. 

  908.         static NativeMidiProgram midiProg;

  909. 

  910.         midiProg.bank    = 0;

  911.         midiProg.program = index;

  912. 

  913.         switch (index)

  914.         {

  915.         case 0:

  916.             midiProg.name = "Echo 1";

  917.             break;

  918.         case 1:

  919.             midiProg.name = "Echo 2";

  920.             break;

  921.         case 2:

  922.             midiProg.name = "Echo 3";

  923.             break;

  924.         case 3:

  925.             midiProg.name = "Simple Echo";

  926.             break;

  927.         case 4:

  928.             midiProg.name = "Canyon";

  929.             break;

  930.         case 5:

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

  932.             break;

  933.         case 6:

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

  935.             break;

  936.         case 7:

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

  938.             break;

  939.         case 8:

  940.             midiProg.name = "Feedback Echo";

  941.             break;

  942.         default:

  943.             midiProg.name = nullptr;

  944.             break;

  945.         }

  946. 

  947.         return &midiProg;

  948.     }

  949. 

  950.     // -------------------------------------------------------------------

  951. 

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

  953.     {

  954.         delete fEffect;

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

  956.     }

  957. 

  958.     PluginClassEND(FxEchoPlugin)

  959.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  960. };

  961. 

  962. // -----------------------------------------------------------------------

  963. 

  964. class FxPhaserPlugin : public FxAbstractPlugin

  965. {

  966. public:

  967.     FxPhaserPlugin(const NativeHostDescriptor* const host)

  968.         : FxAbstractPlugin(host, 15, 12)

  969.     {

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

  971.     }

  972. 

  973. protected:

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

  975.     // Plugin parameter calls

  976. 

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

  978.     {

  979.         if (index >= fParamCount)

  980.             return nullptr;

  981. 

  982.         static NativeParameter param;

  983.         static NativeParameterScalePoint scalePoints[2];

  984. 

  985.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  986. 

  987.         param.name = nullptr;

  988.         param.unit = nullptr;

  989.         param.ranges.def       = 1.0f;

  990.         param.ranges.min       = 0.0f;

  991.         param.ranges.max       = 127.0f;

  992.         param.ranges.step      = 1.0f;

  993.         param.ranges.stepSmall = 1.0f;

  994.         param.ranges.stepLarge = 20.0f;

  995.         param.scalePointCount  = 0;

  996.         param.scalePoints      = nullptr;

  997. 

  998.         switch (index)

  999.         {

  1000.         case 0:

  1001.             hints |= PARAMETER_IS_AUTOMABLE;

  1002.             param.name = "LFO Frequency";

  1003.             param.ranges.def = 36.0f;

  1004.             break;

  1005.         case 1:

  1006.             hints |= PARAMETER_IS_AUTOMABLE;

  1007.             param.name = "LFO Randomness";

  1008.             param.ranges.def = 0.0f;

  1009.             break;

  1010.         case 2:

  1011.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  1012.             param.name = "LFO Type";

  1013.             param.ranges.def = 0.0f;

  1014.             param.ranges.max = 1.0f;

  1015.             param.scalePointCount = 2;

  1016.             param.scalePoints     = scalePoints;

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

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

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

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

  1021.             break;

  1022.         case 3:

  1023.             hints |= PARAMETER_IS_AUTOMABLE;

  1024.             param.name = "LFO Stereo";

  1025.             param.ranges.def = 64.0f;

  1026.             break;

  1027.         case 4:

  1028.             hints |= PARAMETER_IS_AUTOMABLE;

  1029.             param.name = "Depth";

  1030.             param.ranges.def = 110.0f;

  1031.             break;

  1032.         case 5:

  1033.             hints |= PARAMETER_IS_AUTOMABLE;

  1034.             param.name = "Feedback";

  1035.             param.ranges.def = 64.0f;

  1036.             break;

  1037.         case 6:

  1038.             param.name = "Stages";

  1039.             param.ranges.def = 1.0f;

  1040.             param.ranges.min = 1.0f;

  1041.             param.ranges.max = 12.0f;

  1042.             break;

  1043.         case 7:

  1044.             hints |= PARAMETER_IS_AUTOMABLE;

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

  1046.             param.ranges.def = 0.0f;

  1047.             break;

  1048.         case 8:

  1049.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1050.             param.name = "Subtract Output";

  1051.             param.ranges.def = 0.0f;

  1052.             param.ranges.max = 1.0f;

  1053.             break;

  1054.         case 9:

  1055.             hints |= PARAMETER_IS_AUTOMABLE;

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

  1057.             param.ranges.def = 20.0f;

  1058.             break;

  1059.         case 10:

  1060.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1061.             param.name = "Hyper";

  1062.             param.ranges.def = 0.0f;

  1063.             param.ranges.max = 1.0f;

  1064.             break;

  1065.         case 11:

  1066.             hints |= PARAMETER_IS_AUTOMABLE;

  1067.             param.name = "Distortion";

  1068.             param.ranges.def = 0.0f;

  1069.             break;

  1070.         case 12:

  1071.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1072.             param.name = "Analog";

  1073.             param.ranges.def = 0.0f;

  1074.             param.ranges.max = 1.0f;

  1075.             break;

  1076.         }

  1077. 

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

  1079. 

  1080.         return &param;

  1081.     }

  1082. 

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

  1084.     // Plugin midi-program calls

  1085. 

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

  1087.     {

  1088.         if (index >= fProgramCount)

  1089.             return nullptr;

  1090. 

  1091.         static NativeMidiProgram midiProg;

  1092. 

  1093.         midiProg.bank    = 0;

  1094.         midiProg.program = index;

  1095. 

  1096.         switch (index)

  1097.         {

  1098.         case 0:

  1099.             midiProg.name = "Phaser 1";

  1100.             break;

  1101.         case 1:

  1102.             midiProg.name = "Phaser 2";

  1103.             break;

  1104.         case 2:

  1105.             midiProg.name = "Phaser 3";

  1106.             break;

  1107.         case 3:

  1108.             midiProg.name = "Phaser 4";

  1109.             break;

  1110.         case 4:

  1111.             midiProg.name = "Phaser 5";

  1112.             break;

  1113.         case 5:

  1114.             midiProg.name = "Phaser 6";

  1115.             break;

  1116.         case 6:

  1117.             midiProg.name = "APhaser 1";

  1118.             break;

  1119.         case 7:

  1120.             midiProg.name = "APhaser 2";

  1121.             break;

  1122.         case 8:

  1123.             midiProg.name = "APhaser 3";

  1124.             break;

  1125.         case 9:

  1126.             midiProg.name = "APhaser 4";

  1127.             break;

  1128.         case 10:

  1129.             midiProg.name = "APhaser 5";

  1130.             break;

  1131.         case 11:

  1132.             midiProg.name = "APhaser 6";

  1133.             break;

  1134.         default:

  1135.             midiProg.name = nullptr;

  1136.             break;

  1137.         }

  1138. 

  1139.         return &midiProg;

  1140.     }

  1141. 

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

  1143. 

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

  1145.     {

  1146.         delete fEffect;

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

  1148.     }

  1149. 

  1150.     PluginClassEND(FxPhaserPlugin)

  1151.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1152. };

  1153. 

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

  1155. 

  1156. class FxReverbPlugin : public FxAbstractPlugin

  1157. {

  1158. public:

  1159.     FxReverbPlugin(const NativeHostDescriptor* const host)

  1160.         : FxAbstractPlugin(host, 13, 13)

  1161.     {

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

  1163.     }

  1164. 

  1165. protected:

  1166.     // -------------------------------------------------------------------

  1167.     // Plugin parameter calls

  1168. 

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

  1170.     {

  1171.         if (index >= fParamCount)

  1172.             return nullptr;

  1173. 

  1174.         static NativeParameter param;

  1175.         static NativeParameterScalePoint scalePoints[3];

  1176. 

  1177.         int hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;

  1178. 

  1179.         param.name = nullptr;

  1180.         param.unit = nullptr;

  1181.         param.ranges.def       = 1.0f;

  1182.         param.ranges.min       = 0.0f;

  1183.         param.ranges.max       = 127.0f;

  1184.         param.ranges.step      = 1.0f;

  1185.         param.ranges.stepSmall = 1.0f;

  1186.         param.ranges.stepLarge = 20.0f;

  1187.         param.scalePointCount  = 0;

  1188.         param.scalePoints      = nullptr;

  1189. 

  1190.         switch (index)

  1191.         {

  1192.         case 0:

  1193.             hints |= PARAMETER_IS_AUTOMABLE;

  1194.             param.name = "Time";

  1195.             param.ranges.def = 63.0f;

  1196.             break;

  1197.         case 1:

  1198.             param.name = "Delay";

  1199.             param.ranges.def = 24.0f;

  1200.             break;

  1201.         case 2:

  1202.             hints |= PARAMETER_IS_AUTOMABLE;

  1203.             param.name = "Feedback";

  1204.             param.ranges.def = 0.0f;

  1205.             break;

  1206.         case 3:

  1207.             hints = 0x0;

  1208.             param.name = "bw";

  1209.             break;

  1210.         case 4:

  1211.             hints = 0x0;

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

  1213.             break;

  1214.         case 5:

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

  1216.             param.ranges.def = 85.0f;

  1217.             break;

  1218.         case 6:

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

  1220.             param.ranges.def = 5.0f;

  1221.             break;

  1222.         case 7:

  1223.             hints |= PARAMETER_IS_AUTOMABLE;

  1224.             param.name = "Damp";

  1225.             param.ranges.def = 83.0f;

  1226.             param.ranges.min = 64.0f;

  1227.             break;

  1228.         case 8:

  1229.             hints |= PARAMETER_USES_SCALEPOINTS;

  1230.             param.name = "Type";

  1231.             param.ranges.def = 1.0f;

  1232.             param.ranges.max = 2.0f;

  1233.             param.scalePointCount = 3;

  1234.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1241.             break;

  1242.         case 9:

  1243.             param.name = "Room size";

  1244.             param.ranges.def = 64.0f;

  1245.             param.ranges.min = 1.0f;

  1246.             break;

  1247.         case 10:

  1248.             param.name = "Bandwidth";

  1249.             param.ranges.def = 20.0f;

  1250.             break;

  1251.         }

  1252. 

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

  1254. 

  1255.         return &param;

  1256.     }

  1257. 

  1258.     // -------------------------------------------------------------------

  1259.     // Plugin midi-program calls

  1260. 

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

  1262.     {

  1263.         if (index >= fProgramCount)

  1264.             return nullptr;

  1265. 

  1266.         static NativeMidiProgram midiProg;

  1267. 

  1268.         midiProg.bank    = 0;

  1269.         midiProg.program = index;

  1270. 

  1271.         switch (index)

  1272.         {

  1273.         case 0:

  1274.             midiProg.name = "Cathedral1";

  1275.             break;

  1276.         case 1:

  1277.             midiProg.name = "Cathedral2";

  1278.             break;

  1279.         case 2:

  1280.             midiProg.name = "Cathedral3";

  1281.             break;

  1282.         case 3:

  1283.             midiProg.name = "Hall1";

  1284.             break;

  1285.         case 4:

  1286.             midiProg.name = "Hall2";

  1287.             break;

  1288.         case 5:

  1289.             midiProg.name = "Room1";

  1290.             break;

  1291.         case 6:

  1292.             midiProg.name = "Room2";

  1293.             break;

  1294.         case 7:

  1295.             midiProg.name = "Basement";

  1296.             break;

  1297.         case 8:

  1298.             midiProg.name = "Tunnel";

  1299.             break;

  1300.         case 9:

  1301.             midiProg.name = "Echoed1";

  1302.             break;

  1303.         case 10:

  1304.             midiProg.name = "Echoed2";

  1305.             break;

  1306.         case 11:

  1307.             midiProg.name = "VeryLong1";

  1308.             break;

  1309.         case 12:

  1310.             midiProg.name = "VeryLong2";

  1311.             break;

  1312.         default:

  1313.             midiProg.name = nullptr;

  1314.             break;

  1315.         }

  1316. 

  1317.         return &midiProg;

  1318.     }

  1319. 

  1320.     // -------------------------------------------------------------------

  1321. 

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

  1323.     {

  1324.         delete fEffect;

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

  1326.     }

  1327. 

  1328.     PluginClassEND(FxReverbPlugin)

  1329.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1330. };

  1331. 

  1332. // -----------------------------------------------------------------------

  1333. 

  1334. static const NativePluginDescriptor fxAlienWahDesc = {

  1335.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1338.     /* audioIns  */ 2,

  1339.     /* audioOuts */ 2,

  1340.     /* midiIns   */ 0,

  1341.     /* midiOuts  */ 0,

  1342.     /* paramIns  */ 11-2,

  1343.     /* paramOuts */ 0,

  1344.     /* name      */ "ZynAlienWah",

  1345.     /* label     */ "zynAlienWah",

  1346.     /* maker     */ "falkTX",

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

  1348.     PluginDescriptorFILL(FxAlienWahPlugin)

  1349. };

  1350. 

  1351. static const NativePluginDescriptor fxChorusDesc = {

  1352.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1355.     /* audioIns  */ 2,

  1356.     /* audioOuts */ 2,

  1357.     /* midiIns   */ 0,

  1358.     /* midiOuts  */ 0,

  1359.     /* paramIns  */ 12-2,

  1360.     /* paramOuts */ 0,

  1361.     /* name      */ "ZynChorus",

  1362.     /* label     */ "zynChorus",

  1363.     /* maker     */ "falkTX",

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

  1365.     PluginDescriptorFILL(FxChorusPlugin)

  1366. };

  1367. 

  1368. static const NativePluginDescriptor fxDistortionDesc = {

  1369.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1372.     /* audioIns  */ 2,

  1373.     /* audioOuts */ 2,

  1374.     /* midiIns   */ 0,

  1375.     /* midiOuts  */ 0,

  1376.     /* paramIns  */ 11-2,

  1377.     /* paramOuts */ 0,

  1378.     /* name      */ "ZynDistortion",

  1379.     /* label     */ "zynDistortion",

  1380.     /* maker     */ "falkTX",

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

  1382.     PluginDescriptorFILL(FxDistortionPlugin)

  1383. };

  1384. 

  1385. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1386.     /* category  */ PLUGIN_CATEGORY_FILTER,

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

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

  1389.     /* audioIns  */ 2,

  1390.     /* audioOuts */ 2,

  1391.     /* midiIns   */ 0,

  1392.     /* midiOuts  */ 0,

  1393.     /* paramIns  */ 10-2,

  1394.     /* paramOuts */ 0,

  1395.     /* name      */ "ZynDynamicFilter",

  1396.     /* label     */ "zynDynamicFilter",

  1397.     /* maker     */ "falkTX",

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

  1399.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1400. };

  1401. 

  1402. static const NativePluginDescriptor fxEchoDesc = {

  1403.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  1406.     /* audioIns  */ 2,

  1407.     /* audioOuts */ 2,

  1408.     /* midiIns   */ 0,

  1409.     /* midiOuts  */ 0,

  1410.     /* paramIns  */ 7-2,

  1411.     /* paramOuts */ 0,

  1412.     /* name      */ "ZynEcho",

  1413.     /* label     */ "zynEcho",

  1414.     /* maker     */ "falkTX",

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

  1416.     PluginDescriptorFILL(FxEchoPlugin)

  1417. };

  1418. 

  1419. static const NativePluginDescriptor fxPhaserDesc = {

  1420.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1423.     /* audioIns  */ 2,

  1424.     /* audioOuts */ 2,

  1425.     /* midiIns   */ 0,

  1426.     /* midiOuts  */ 0,

  1427.     /* paramIns  */ 15-2,

  1428.     /* paramOuts */ 0,

  1429.     /* name      */ "ZynPhaser",

  1430.     /* label     */ "zynPhaser",

  1431.     /* maker     */ "falkTX",

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

  1433.     PluginDescriptorFILL(FxPhaserPlugin)

  1434. };

  1435. 

  1436. static const NativePluginDescriptor fxReverbDesc = {

  1437.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  1440.     /* audioIns  */ 2,

  1441.     /* audioOuts */ 2,

  1442.     /* midiIns   */ 0,

  1443.     /* midiOuts  */ 0,

  1444.     /* paramIns  */ 13-2,

  1445.     /* paramOuts */ 0,

  1446.     /* name      */ "ZynReverb",

  1447.     /* label     */ "zynReverb",

  1448.     /* maker     */ "falkTX",

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

  1450.     PluginDescriptorFILL(FxReverbPlugin)

  1451. };

  1452. 

  1453. // -----------------------------------------------------------------------

  1454. 

  1455. CARLA_EXPORT

  1456. void carla_register_native_plugin_zynaddsubfx_fx()

  1457. {

  1458.     carla_register_native_plugin(&fxAlienWahDesc);

  1459.     carla_register_native_plugin(&fxChorusDesc);

  1460.     carla_register_native_plugin(&fxDistortionDesc);

  1461.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1462.     carla_register_native_plugin(&fxEchoDesc);

  1463.     carla_register_native_plugin(&fxPhaserDesc);

  1464.     carla_register_native_plugin(&fxReverbDesc);

  1465. }

  1466. 

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