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

1459 lines
43KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaNative.hpp"

  19. 

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

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

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

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

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

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

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

  27. 

  28. #include "juce_audio_basics.h"

  29. using juce::FloatVectorOperations;

  30. 

  31. // -----------------------------------------------------------------------

  32. 

  33. class FxAbstractPlugin : public NativePluginClass

  34. {

  35. protected:

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

  37.         : NativePluginClass(host),

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

  39.           fProgramCount(programCount),

  40.           fEffect(nullptr),

  41.           efxoutl(nullptr),

  42.           efxoutr(nullptr),

  43.           fFirstInit(true)

  44.     {

  45.         const uint32_t bufferSize(getBufferSize());

  46.         efxoutl = new float[bufferSize];

  47.         efxoutr = new float[bufferSize];

  48. 

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

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

  51.     }

  52. 

  53.     ~FxAbstractPlugin() override

  54.     {

  55.         if (efxoutl != nullptr)

  56.         {

  57.             delete[] efxoutl;

  58.             efxoutl = nullptr;

  59.         }

  60. 

  61.         if (efxoutr != nullptr)

  62.         {

  63.             delete[] efxoutr;

  64.             efxoutr = nullptr;

  65.         }

  66. 

  67.         if (fEffect != nullptr)

  68.         {

  69.             delete fEffect;

  70.             fEffect = nullptr;

  71.         }

  72.     }

  73. 

  74.     // -------------------------------------------------------------------

  75.     // Plugin parameter calls

  76. 

  77.     uint32_t getParameterCount() const final

  78.     {

  79.         return fParamCount;

  80.     }

  81. 

  82.     float getParameterValue(const uint32_t index) const final

  83.     {

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

  85.     }

  86. 

  87.     // -------------------------------------------------------------------

  88.     // Plugin midi-program calls

  89. 

  90.     uint32_t getMidiProgramCount() const final

  91.     {

  92.         return fProgramCount;

  93.     }

  94. 

  95.     // -------------------------------------------------------------------

  96.     // Plugin state calls

  97. 

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

  99.     {

  100.         fFirstInit = false;

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

  102.     }

  103. 

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

  105.     {

  106.         fFirstInit = false;

  107.         fEffect->setpreset(program);

  108. 

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

  110.         hostSetVolume(volume);

  111. 

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

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

  114.         hostSetPanning(panning);

  115. 

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

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

  118.     }

  119. 

  120.     // -------------------------------------------------------------------

  121.     // Plugin process calls

  122. 

  123.     void activate() final

  124.     {

  125.         fEffect->cleanup();

  126. 

  127.         if (fFirstInit)

  128.         {

  129.             fFirstInit = false;

  130.             hostSetDryWet(0.5f);

  131.         }

  132.     }

  133. 

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

  135.     {

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

  137. 

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

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

  140.     }

  141. 

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

  143.     // Plugin dispatcher

  144. 

  145.     void bufferSizeChanged(const uint32_t bufferSize) final

  146.     {

  147.         delete[] efxoutl;

  148.         delete[] efxoutr;

  149.         efxoutl = new float[bufferSize];

  150.         efxoutr = new float[bufferSize];

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

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

  153. 

  154.         doReinit(bufferSize, getSampleRate());

  155.     }

  156. 

  157.     void sampleRateChanged(const double sampleRate) final

  158.     {

  159.         doReinit(getBufferSize(), sampleRate);

  160.     }

  161. 

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

  163.     {

  164.         float params[fParamCount];

  165. 

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

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

  168. 

  169.         reinit(bufferSize, sampleRate);

  170. 

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

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

  173.     }

  174. 

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

  176. 

  177.     // -------------------------------------------------------------------

  178. 

  179.     const uint32_t fParamCount;

  180.     const uint32_t fProgramCount;

  181. 

  182.     Effect* fEffect;

  183.     float*  efxoutl;

  184.     float*  efxoutr;

  185.     bool    fFirstInit;

  186. };

  187. 

  188. // -----------------------------------------------------------------------

  189. 

  190. class FxAlienWahPlugin : public FxAbstractPlugin

  191. {

  192. public:

  193.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

  194.         : FxAbstractPlugin(host, 11, 4)

  195.     {

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

  197.     }

  198. 

  199. protected:

  200.     // -------------------------------------------------------------------

  201.     // Plugin parameter calls

  202. 

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

  204.     {

  205.         if (index >= fParamCount)

  206.             return nullptr;

  207. 

  208.         static NativeParameter param;

  209.         static NativeParameterScalePoint scalePoints[2];

  210. 

  211.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  212. 

  213.         param.name = nullptr;

  214.         param.unit = nullptr;

  215.         param.ranges.def       = 1.0f;

  216.         param.ranges.min       = 0.0f;

  217.         param.ranges.max       = 127.0f;

  218.         param.ranges.step      = 1.0f;

  219.         param.ranges.stepSmall = 1.0f;

  220.         param.ranges.stepLarge = 20.0f;

  221.         param.scalePointCount  = 0;

  222.         param.scalePoints      = nullptr;

  223. 

  224.         switch (index)

  225.         {

  226.         case 0:

  227.             hints |= PARAMETER_IS_AUTOMABLE;

  228.             param.name = "LFO Frequency";

  229.             param.ranges.def = 70.0f;

  230.             break;

  231.         case 1:

  232.             hints |= PARAMETER_IS_AUTOMABLE;

  233.             param.name = "LFO Randomness";

  234.             param.ranges.def = 0.0f;

  235.             break;

  236.         case 2:

  237.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  238.             param.name = "LFO Type";

  239.             param.ranges.def = 0.0f;

  240.             param.ranges.max = 1.0f;

  241.             param.scalePointCount = 2;

  242.             param.scalePoints     = scalePoints;

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

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

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

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

  247.             break;

  248.         case 3:

  249.             hints |= PARAMETER_IS_AUTOMABLE;

  250.             param.name = "LFO Stereo";

  251.             param.ranges.def = 62.0f;

  252.             break;

  253.         case 4:

  254.             hints |= PARAMETER_IS_AUTOMABLE;

  255.             param.name = "Depth";

  256.             param.ranges.def = 60.0f;

  257.             break;

  258.         case 5:

  259.             hints |= PARAMETER_IS_AUTOMABLE;

  260.             param.name = "Feedback";

  261.             param.ranges.def = 105.0f;

  262.             break;

  263.         case 6:

  264.             param.name = "Delay";

  265.             param.ranges.def = 25.0f;

  266.             param.ranges.min = 1.0f;

  267.             param.ranges.max = 100.0f;

  268.             break;

  269.         case 7:

  270.             hints |= PARAMETER_IS_AUTOMABLE;

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

  272.             param.ranges.def = 0.0f;

  273.             break;

  274.         case 8:

  275.             hints |= PARAMETER_IS_AUTOMABLE;

  276.             param.name = "Phase";

  277.             param.ranges.def = 64.0f;

  278.             break;

  279.         }

  280. 

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

  282. 

  283.         return &param;

  284.     }

  285. 

  286.     // -------------------------------------------------------------------

  287.     // Plugin midi-program calls

  288. 

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

  290.     {

  291.         if (index >= fProgramCount)

  292.             return nullptr;

  293. 

  294.         static NativeMidiProgram midiProg;

  295. 

  296.         midiProg.bank    = 0;

  297.         midiProg.program = index;

  298. 

  299.         switch (index)

  300.         {

  301.         case 0:

  302.             midiProg.name = "AlienWah1";

  303.             break;

  304.         case 1:

  305.             midiProg.name = "AlienWah2";

  306.             break;

  307.         case 2:

  308.             midiProg.name = "AlienWah3";

  309.             break;

  310.         case 3:

  311.             midiProg.name = "AlienWah4";

  312.             break;

  313.         default:

  314.             midiProg.name = nullptr;

  315.             break;

  316.         }

  317. 

  318.         return &midiProg;

  319.     }

  320. 

  321.     // -------------------------------------------------------------------

  322. 

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

  324.     {

  325.         delete fEffect;

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

  327.     }

  328. 

  329.     PluginClassEND(FxAlienWahPlugin)

  330.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  331. };

  332. 

  333. // -----------------------------------------------------------------------

  334. 

  335. class FxChorusPlugin : public FxAbstractPlugin

  336. {

  337. public:

  338.     FxChorusPlugin(const NativeHostDescriptor* const host)

  339.         : FxAbstractPlugin(host, 12, 10)

  340.     {

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

  342.     }

  343. 

  344. protected:

  345.     // -------------------------------------------------------------------

  346.     // Plugin parameter calls

  347. 

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

  349.     {

  350.         if (index >= fParamCount)

  351.             return nullptr;

  352. 

  353.         static NativeParameter param;

  354.         static NativeParameterScalePoint scalePoints[2];

  355. 

  356.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  357. 

  358.         param.name = nullptr;

  359.         param.unit = nullptr;

  360.         param.ranges.def       = 1.0f;

  361.         param.ranges.min       = 0.0f;

  362.         param.ranges.max       = 127.0f;

  363.         param.ranges.step      = 1.0f;

  364.         param.ranges.stepSmall = 1.0f;

  365.         param.ranges.stepLarge = 20.0f;

  366.         param.scalePointCount  = 0;

  367.         param.scalePoints      = nullptr;

  368. 

  369.         switch (index)

  370.         {

  371.         case 0:

  372.             hints |= PARAMETER_IS_AUTOMABLE;

  373.             param.name = "LFO Frequency";

  374.             param.ranges.def = 50.0f;

  375.             break;

  376.         case 1:

  377.             hints |= PARAMETER_IS_AUTOMABLE;

  378.             param.name = "LFO Randomness";

  379.             param.ranges.def = 0.0f;

  380.             break;

  381.         case 2:

  382.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  383.             param.name = "LFO Type";

  384.             param.ranges.def = 0.0f;

  385.             param.ranges.max = 1.0f;

  386.             param.scalePointCount = 2;

  387.             param.scalePoints     = scalePoints;

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

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

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

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

  392.             break;

  393.         case 3:

  394.             hints |= PARAMETER_IS_AUTOMABLE;

  395.             param.name = "LFO Stereo";

  396.             param.ranges.def = 90.0f;

  397.             break;

  398.         case 4:

  399.             hints |= PARAMETER_IS_AUTOMABLE;

  400.             param.name = "Depth";

  401.             param.ranges.def = 40.0f;

  402.             break;

  403.         case 5:

  404.             hints |= PARAMETER_IS_AUTOMABLE;

  405.             param.name = "Delay";

  406.             param.ranges.def = 85.0f;

  407.             break;

  408.         case 6:

  409.             hints |= PARAMETER_IS_AUTOMABLE;

  410.             param.name = "Feedback";

  411.             param.ranges.def = 64.0f;

  412.             break;

  413.         case 7:

  414.             hints |= PARAMETER_IS_AUTOMABLE;

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

  416.             param.ranges.def = 119.0f;

  417.             break;

  418.         case 8:

  419.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  420.             param.name = "Flange Mode";

  421.             param.ranges.def = 0.0f;

  422.             param.ranges.max = 1.0f;

  423.             break;

  424.         case 9:

  425.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  426.             param.name = "Subtract Output";

  427.             param.ranges.def = 0.0f;

  428.             param.ranges.max = 1.0f;

  429.             break;

  430.         }

  431. 

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

  433. 

  434.         return &param;

  435.     }

  436. 

  437.     // -------------------------------------------------------------------

  438.     // Plugin midi-program calls

  439. 

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

  441.     {

  442.         if (index >= fProgramCount)

  443.             return nullptr;

  444. 

  445.         static NativeMidiProgram midiProg;

  446. 

  447.         midiProg.bank    = 0;

  448.         midiProg.program = index;

  449. 

  450.         switch (index)

  451.         {

  452.         case 0:

  453.             midiProg.name = "Chorus1";

  454.             break;

  455.         case 1:

  456.             midiProg.name = "Chorus2";

  457.             break;

  458.         case 2:

  459.             midiProg.name = "Chorus3";

  460.             break;

  461.         case 3:

  462.             midiProg.name = "Celeste1";

  463.             break;

  464.         case 4:

  465.             midiProg.name = "Celeste2";

  466.             break;

  467.         case 5:

  468.             midiProg.name = "Flange1";

  469.             break;

  470.         case 6:

  471.             midiProg.name = "Flange2";

  472.             break;

  473.         case 7:

  474.             midiProg.name = "Flange3";

  475.             break;

  476.         case 8:

  477.             midiProg.name = "Flange4";

  478.             break;

  479.         case 9:

  480.             midiProg.name = "Flange5";

  481.             break;

  482.         default:

  483.             midiProg.name = nullptr;

  484.             break;

  485.         }

  486. 

  487.         return &midiProg;

  488.     }

  489. 

  490.     // -------------------------------------------------------------------

  491. 

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

  493.     {

  494.         delete fEffect;

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

  496.     }

  497. 

  498.     PluginClassEND(FxChorusPlugin)

  499.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  500. };

  501. 

  502. // -----------------------------------------------------------------------

  503. 

  504. class FxDistortionPlugin : public FxAbstractPlugin

  505. {

  506. public:

  507.     FxDistortionPlugin(const NativeHostDescriptor* const host)

  508.         : FxAbstractPlugin(host, 11, 6)

  509.     {

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

  511.     }

  512. 

  513. protected:

  514.     // -------------------------------------------------------------------

  515.     // Plugin parameter calls

  516. 

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

  518.     {

  519.         if (index >= fParamCount)

  520.             return nullptr;

  521. 

  522.         static NativeParameter param;

  523.         static NativeParameterScalePoint scalePoints[14];

  524. 

  525.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  526. 

  527.         param.name = nullptr;

  528.         param.unit = nullptr;

  529.         param.ranges.def       = 1.0f;

  530.         param.ranges.min       = 0.0f;

  531.         param.ranges.max       = 127.0f;

  532.         param.ranges.step      = 1.0f;

  533.         param.ranges.stepSmall = 1.0f;

  534.         param.ranges.stepLarge = 20.0f;

  535.         param.scalePointCount  = 0;

  536.         param.scalePoints      = nullptr;

  537. 

  538.         switch (index)

  539.         {

  540.         case 0:

  541.             hints |= PARAMETER_IS_AUTOMABLE;

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

  543.             param.ranges.def = 35.0f;

  544.             break;

  545.         case 1:

  546.             hints |= PARAMETER_IS_AUTOMABLE;

  547.             param.name = "Drive";

  548.             param.ranges.def = 56.0f;

  549.             break;

  550.         case 2:

  551.             hints |= PARAMETER_IS_AUTOMABLE;

  552.             param.name = "Level";

  553.             param.ranges.def = 70.0f;

  554.             break;

  555.         case 3:

  556.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_USES_SCALEPOINTS;

  557.             param.name = "Type";

  558.             param.ranges.def = 0.0f;

  559.             param.ranges.max = 13.0f;

  560.             param.scalePointCount = 14;

  561.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  590.             break;

  591.         case 4:

  592.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  593.             param.name = "Negate";

  594.             param.ranges.def = 0.0f;

  595.             param.ranges.max = 1.0f;

  596.             break;

  597.         case 5:

  598.             hints |= PARAMETER_IS_AUTOMABLE;

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

  600.             param.ranges.def = 96.0f;

  601.             break;

  602.         case 6:

  603.             hints |= PARAMETER_IS_AUTOMABLE;

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

  605.             param.ranges.def = 0.0f;

  606.             break;

  607.         case 7:

  608.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  609.             param.name = "Stereo";

  610.             param.ranges.def = 0.0f;

  611.             param.ranges.max = 1.0f;

  612.             break;

  613.         case 8:

  614.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

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

  616.             param.ranges.def = 0.0f;

  617.             param.ranges.max = 1.0f;

  618.             break;

  619.         }

  620. 

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

  622. 

  623.         return &param;

  624.     }

  625. 

  626.     // -------------------------------------------------------------------

  627.     // Plugin midi-program calls

  628. 

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

  630.     {

  631.         if (index >= fProgramCount)

  632.             return nullptr;

  633. 

  634.         static NativeMidiProgram midiProg;

  635. 

  636.         midiProg.bank    = 0;

  637.         midiProg.program = index;

  638. 

  639.         switch (index)

  640.         {

  641.         case 0:

  642.             midiProg.name = "Overdrive 1";

  643.             break;

  644.         case 1:

  645.             midiProg.name = "Overdrive 2";

  646.             break;

  647.         case 2:

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

  649.             break;

  650.         case 3:

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

  652.             break;

  653.         case 4:

  654.             midiProg.name = "Guitar Amp";

  655.             break;

  656.         case 5:

  657.             midiProg.name = "Quantisize";

  658.             break;

  659.         default:

  660.             midiProg.name = nullptr;

  661.             break;

  662.         }

  663. 

  664.         return &midiProg;

  665.     }

  666. 

  667.     // -------------------------------------------------------------------

  668. 

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

  670.     {

  671.         delete fEffect;

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

  673.     }

  674. 

  675.     PluginClassEND(FxDistortionPlugin)

  676.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  677. };

  678. 

  679. // -----------------------------------------------------------------------

  680. 

  681. class FxDynamicFilterPlugin : public FxAbstractPlugin

  682. {

  683. public:

  684.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

  685.         : FxAbstractPlugin(host, 10, 5)

  686.     {

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

  688.     }

  689. 

  690. protected:

  691.     // -------------------------------------------------------------------

  692.     // Plugin parameter calls

  693. 

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

  695.     {

  696.         if (index >= fParamCount)

  697.             return nullptr;

  698. 

  699.         static NativeParameter param;

  700.         static NativeParameterScalePoint scalePoints[2];

  701. 

  702.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  703. 

  704.         param.name = nullptr;

  705.         param.unit = nullptr;

  706.         param.ranges.def       = 1.0f;

  707.         param.ranges.min       = 0.0f;

  708.         param.ranges.max       = 127.0f;

  709.         param.ranges.step      = 1.0f;

  710.         param.ranges.stepSmall = 1.0f;

  711.         param.ranges.stepLarge = 20.0f;

  712.         param.scalePointCount  = 0;

  713.         param.scalePoints      = nullptr;

  714. 

  715.         switch (index)

  716.         {

  717.         case 0:

  718.             hints |= PARAMETER_IS_AUTOMABLE;

  719.             param.name = "LFO Frequency";

  720.             param.ranges.def = 80.0f;

  721.             break;

  722.         case 1:

  723.             hints |= PARAMETER_IS_AUTOMABLE;

  724.             param.name = "LFO Randomness";

  725.             param.ranges.def = 0.0f;

  726.             break;

  727.         case 2:

  728.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  729.             param.name = "LFO Type";

  730.             param.ranges.def = 0.0f;

  731.             param.ranges.max = 1.0f;

  732.             param.scalePointCount = 2;

  733.             param.scalePoints     = scalePoints;

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

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

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

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

  738.             break;

  739.         case 3:

  740.             hints |= PARAMETER_IS_AUTOMABLE;

  741.             param.name = "LFO Stereo";

  742.             param.ranges.def = 64.0f;

  743.             break;

  744.         case 4:

  745.             hints |= PARAMETER_IS_AUTOMABLE;

  746.             param.name = "LFO Depth";

  747.             param.ranges.def = 0.0f;

  748.             break;

  749.         case 5:

  750.             hints |= PARAMETER_IS_AUTOMABLE;

  751.             param.name = "Amp sns";

  752.             param.ranges.def = 90.0f;

  753.             break;

  754.         case 6:

  755.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

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

  757.             param.ranges.def = 0.0f;

  758.             param.ranges.max = 1.0f;

  759.             break;

  760.         case 7:

  761.             hints |= PARAMETER_IS_AUTOMABLE;

  762.             param.name = "Amp Smooth";

  763.             param.ranges.def = 60.0f;

  764.             break;

  765.         }

  766. 

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

  768. 

  769.         return &param;

  770.     }

  771. 

  772.     // -------------------------------------------------------------------

  773.     // Plugin midi-program calls

  774. 

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

  776.     {

  777.         if (index >= fProgramCount)

  778.             return nullptr;

  779. 

  780.         static NativeMidiProgram midiProg;

  781. 

  782.         midiProg.bank    = 0;

  783.         midiProg.program = index;

  784. 

  785.         switch (index)

  786.         {

  787.         case 0:

  788.             midiProg.name = "WahWah";

  789.             break;

  790.         case 1:

  791.             midiProg.name = "AutoWah";

  792.             break;

  793.         case 2:

  794.             midiProg.name = "Sweep";

  795.             break;

  796.         case 3:

  797.             midiProg.name = "VocalMorph1";

  798.             break;

  799.         case 4:

  800.             midiProg.name = "VocalMorph2";

  801.             break;

  802.         default:

  803.             midiProg.name = nullptr;

  804.             break;

  805.         }

  806. 

  807.         return &midiProg;

  808.     }

  809. 

  810.     // -------------------------------------------------------------------

  811. 

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

  813.     {

  814.         delete fEffect;

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

  816.     }

  817. 

  818.     PluginClassEND(FxDynamicFilterPlugin)

  819.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  820. };

  821. 

  822. // -----------------------------------------------------------------------

  823. 

  824. class FxEchoPlugin : public FxAbstractPlugin

  825. {

  826. public:

  827.     FxEchoPlugin(const NativeHostDescriptor* const host)

  828.         : FxAbstractPlugin(host, 7, 9)

  829.     {

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

  831.     }

  832. 

  833. protected:

  834.     // -------------------------------------------------------------------

  835.     // Plugin parameter calls

  836. 

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

  838.     {

  839.         if (index >= fParamCount)

  840.             return nullptr;

  841. 

  842.         static NativeParameter param;

  843. 

  844.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  845. 

  846.         param.name = nullptr;

  847.         param.unit = nullptr;

  848.         param.ranges.def       = 1.0f;

  849.         param.ranges.min       = 0.0f;

  850.         param.ranges.max       = 127.0f;

  851.         param.ranges.step      = 1.0f;

  852.         param.ranges.stepSmall = 1.0f;

  853.         param.ranges.stepLarge = 20.0f;

  854.         param.scalePointCount  = 0;

  855.         param.scalePoints      = nullptr;

  856. 

  857.         switch (index)

  858.         {

  859.         case 0:

  860.             hints |= PARAMETER_IS_AUTOMABLE;

  861.             param.name = "Delay";

  862.             param.ranges.def = 35.0f;

  863.             break;

  864.         case 1:

  865.             hints |= PARAMETER_IS_AUTOMABLE;

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

  867.             param.ranges.def = 64.0f;

  868.             break;

  869.         case 2:

  870.             hints |= PARAMETER_IS_AUTOMABLE;

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

  872.             param.ranges.def = 30.0f;

  873.             break;

  874.         case 3:

  875.             hints |= PARAMETER_IS_AUTOMABLE;

  876.             param.name = "Feedback";

  877.             param.ranges.def = 59.0f;

  878.             break;

  879.         case 4:

  880.             hints |= PARAMETER_IS_AUTOMABLE;

  881.             param.name = "High Damp";

  882.             param.ranges.def = 0.0f;

  883.             break;

  884.         }

  885. 

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

  887. 

  888.         return &param;

  889.     }

  890. 

  891.     // -------------------------------------------------------------------

  892.     // Plugin midi-program calls

  893. 

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

  895.     {

  896.         if (index >= fProgramCount)

  897.             return nullptr;

  898. 

  899.         static NativeMidiProgram midiProg;

  900. 

  901.         midiProg.bank    = 0;

  902.         midiProg.program = index;

  903. 

  904.         switch (index)

  905.         {

  906.         case 0:

  907.             midiProg.name = "Echo 1";

  908.             break;

  909.         case 1:

  910.             midiProg.name = "Echo 2";

  911.             break;

  912.         case 2:

  913.             midiProg.name = "Echo 3";

  914.             break;

  915.         case 3:

  916.             midiProg.name = "Simple Echo";

  917.             break;

  918.         case 4:

  919.             midiProg.name = "Canyon";

  920.             break;

  921.         case 5:

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

  923.             break;

  924.         case 6:

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

  926.             break;

  927.         case 7:

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

  929.             break;

  930.         case 8:

  931.             midiProg.name = "Feedback Echo";

  932.             break;

  933.         default:

  934.             midiProg.name = nullptr;

  935.             break;

  936.         }

  937. 

  938.         return &midiProg;

  939.     }

  940. 

  941.     // -------------------------------------------------------------------

  942. 

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

  944.     {

  945.         delete fEffect;

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

  947.     }

  948. 

  949.     PluginClassEND(FxEchoPlugin)

  950.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  951. };

  952. 

  953. // -----------------------------------------------------------------------

  954. 

  955. class FxPhaserPlugin : public FxAbstractPlugin

  956. {

  957. public:

  958.     FxPhaserPlugin(const NativeHostDescriptor* const host)

  959.         : FxAbstractPlugin(host, 15, 12)

  960.     {

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

  962.     }

  963. 

  964. protected:

  965.     // -------------------------------------------------------------------

  966.     // Plugin parameter calls

  967. 

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

  969.     {

  970.         if (index >= fParamCount)

  971.             return nullptr;

  972. 

  973.         static NativeParameter param;

  974.         static NativeParameterScalePoint scalePoints[2];

  975. 

  976.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_INTEGER;

  977. 

  978.         param.name = nullptr;

  979.         param.unit = nullptr;

  980.         param.ranges.def       = 1.0f;

  981.         param.ranges.min       = 0.0f;

  982.         param.ranges.max       = 127.0f;

  983.         param.ranges.step      = 1.0f;

  984.         param.ranges.stepSmall = 1.0f;

  985.         param.ranges.stepLarge = 20.0f;

  986.         param.scalePointCount  = 0;

  987.         param.scalePoints      = nullptr;

  988. 

  989.         switch (index)

  990.         {

  991.         case 0:

  992.             hints |= PARAMETER_IS_AUTOMABLE;

  993.             param.name = "LFO Frequency";

  994.             param.ranges.def = 36.0f;

  995.             break;

  996.         case 1:

  997.             hints |= PARAMETER_IS_AUTOMABLE;

  998.             param.name = "LFO Randomness";

  999.             param.ranges.def = 0.0f;

  1000.             break;

  1001.         case 2:

  1002.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN|PARAMETER_USES_SCALEPOINTS;

  1003.             param.name = "LFO Type";

  1004.             param.ranges.def = 0.0f;

  1005.             param.ranges.max = 1.0f;

  1006.             param.scalePointCount = 2;

  1007.             param.scalePoints     = scalePoints;

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

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

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

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

  1012.             break;

  1013.         case 3:

  1014.             hints |= PARAMETER_IS_AUTOMABLE;

  1015.             param.name = "LFO Stereo";

  1016.             param.ranges.def = 64.0f;

  1017.             break;

  1018.         case 4:

  1019.             hints |= PARAMETER_IS_AUTOMABLE;

  1020.             param.name = "Depth";

  1021.             param.ranges.def = 110.0f;

  1022.             break;

  1023.         case 5:

  1024.             hints |= PARAMETER_IS_AUTOMABLE;

  1025.             param.name = "Feedback";

  1026.             param.ranges.def = 64.0f;

  1027.             break;

  1028.         case 6:

  1029.             param.name = "Stages";

  1030.             param.ranges.def = 1.0f;

  1031.             param.ranges.min = 1.0f;

  1032.             param.ranges.max = 12.0f;

  1033.             break;

  1034.         case 7:

  1035.             hints |= PARAMETER_IS_AUTOMABLE;

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

  1037.             param.ranges.def = 0.0f;

  1038.             break;

  1039.         case 8:

  1040.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1041.             param.name = "Subtract Output";

  1042.             param.ranges.def = 0.0f;

  1043.             param.ranges.max = 1.0f;

  1044.             break;

  1045.         case 9:

  1046.             hints |= PARAMETER_IS_AUTOMABLE;

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

  1048.             param.ranges.def = 20.0f;

  1049.             break;

  1050.         case 10:

  1051.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1052.             param.name = "Hyper";

  1053.             param.ranges.def = 0.0f;

  1054.             param.ranges.max = 1.0f;

  1055.             break;

  1056.         case 11:

  1057.             hints |= PARAMETER_IS_AUTOMABLE;

  1058.             param.name = "Distortion";

  1059.             param.ranges.def = 0.0f;

  1060.             break;

  1061.         case 12:

  1062.             hints |= PARAMETER_IS_AUTOMABLE|PARAMETER_IS_BOOLEAN;

  1063.             param.name = "Analog";

  1064.             param.ranges.def = 0.0f;

  1065.             param.ranges.max = 1.0f;

  1066.             break;

  1067.         }

  1068. 

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

  1070. 

  1071.         return &param;

  1072.     }

  1073. 

  1074.     // -------------------------------------------------------------------

  1075.     // Plugin midi-program calls

  1076. 

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

  1078.     {

  1079.         if (index >= fProgramCount)

  1080.             return nullptr;

  1081. 

  1082.         static NativeMidiProgram midiProg;

  1083. 

  1084.         midiProg.bank    = 0;

  1085.         midiProg.program = index;

  1086. 

  1087.         switch (index)

  1088.         {

  1089.         case 0:

  1090.             midiProg.name = "Phaser 1";

  1091.             break;

  1092.         case 1:

  1093.             midiProg.name = "Phaser 2";

  1094.             break;

  1095.         case 2:

  1096.             midiProg.name = "Phaser 3";

  1097.             break;

  1098.         case 3:

  1099.             midiProg.name = "Phaser 4";

  1100.             break;

  1101.         case 4:

  1102.             midiProg.name = "Phaser 5";

  1103.             break;

  1104.         case 5:

  1105.             midiProg.name = "Phaser 6";

  1106.             break;

  1107.         case 6:

  1108.             midiProg.name = "APhaser 1";

  1109.             break;

  1110.         case 7:

  1111.             midiProg.name = "APhaser 2";

  1112.             break;

  1113.         case 8:

  1114.             midiProg.name = "APhaser 3";

  1115.             break;

  1116.         case 9:

  1117.             midiProg.name = "APhaser 4";

  1118.             break;

  1119.         case 10:

  1120.             midiProg.name = "APhaser 5";

  1121.             break;

  1122.         case 11:

  1123.             midiProg.name = "APhaser 6";

  1124.             break;

  1125.         default:

  1126.             midiProg.name = nullptr;

  1127.             break;

  1128.         }

  1129. 

  1130.         return &midiProg;

  1131.     }

  1132. 

  1133.     // -------------------------------------------------------------------

  1134. 

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

  1136.     {

  1137.         delete fEffect;

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

  1139.     }

  1140. 

  1141.     PluginClassEND(FxPhaserPlugin)

  1142.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1143. };

  1144. 

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

  1146. 

  1147. class FxReverbPlugin : public FxAbstractPlugin

  1148. {

  1149. public:

  1150.     FxReverbPlugin(const NativeHostDescriptor* const host)

  1151.         : FxAbstractPlugin(host, 13, 13)

  1152.     {

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

  1154.     }

  1155. 

  1156. protected:

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

  1158.     // Plugin parameter calls

  1159. 

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

  1161.     {

  1162.         if (index >= fParamCount)

  1163.             return nullptr;

  1164. 

  1165.         static NativeParameter param;

  1166.         static NativeParameterScalePoint scalePoints[3];

  1167. 

  1168.         int hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;

  1169. 

  1170.         param.name = nullptr;

  1171.         param.unit = nullptr;

  1172.         param.ranges.def       = 1.0f;

  1173.         param.ranges.min       = 0.0f;

  1174.         param.ranges.max       = 127.0f;

  1175.         param.ranges.step      = 1.0f;

  1176.         param.ranges.stepSmall = 1.0f;

  1177.         param.ranges.stepLarge = 20.0f;

  1178.         param.scalePointCount  = 0;

  1179.         param.scalePoints      = nullptr;

  1180. 

  1181.         switch (index)

  1182.         {

  1183.         case 0:

  1184.             hints |= PARAMETER_IS_AUTOMABLE;

  1185.             param.name = "Time";

  1186.             param.ranges.def = 63.0f;

  1187.             break;

  1188.         case 1:

  1189.             param.name = "Delay";

  1190.             param.ranges.def = 24.0f;

  1191.             break;

  1192.         case 2:

  1193.             hints |= PARAMETER_IS_AUTOMABLE;

  1194.             param.name = "Feedback";

  1195.             param.ranges.def = 0.0f;

  1196.             break;

  1197.         case 3:

  1198.             hints = 0x0;

  1199.             param.name = "bw";

  1200.             break;

  1201.         case 4:

  1202.             hints = 0x0;

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

  1204.             break;

  1205.         case 5:

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

  1207.             param.ranges.def = 85.0f;

  1208.             break;

  1209.         case 6:

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

  1211.             param.ranges.def = 5.0f;

  1212.             break;

  1213.         case 7:

  1214.             hints |= PARAMETER_IS_AUTOMABLE;

  1215.             param.name = "Damp";

  1216.             param.ranges.def = 83.0f;

  1217.             param.ranges.min = 64.0f;

  1218.             break;

  1219.         case 8:

  1220.             hints |= PARAMETER_USES_SCALEPOINTS;

  1221.             param.name = "Type";

  1222.             param.ranges.def = 1.0f;

  1223.             param.ranges.max = 2.0f;

  1224.             param.scalePointCount = 3;

  1225.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1232.             break;

  1233.         case 9:

  1234.             param.name = "Room size";

  1235.             param.ranges.def = 64.0f;

  1236.             param.ranges.min = 1.0f;

  1237.             break;

  1238.         case 10:

  1239.             param.name = "Bandwidth";

  1240.             param.ranges.def = 20.0f;

  1241.             break;

  1242.         }

  1243. 

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

  1245. 

  1246.         return &param;

  1247.     }

  1248. 

  1249.     // -------------------------------------------------------------------

  1250.     // Plugin midi-program calls

  1251. 

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

  1253.     {

  1254.         if (index >= fProgramCount)

  1255.             return nullptr;

  1256. 

  1257.         static NativeMidiProgram midiProg;

  1258. 

  1259.         midiProg.bank    = 0;

  1260.         midiProg.program = index;

  1261. 

  1262.         switch (index)

  1263.         {

  1264.         case 0:

  1265.             midiProg.name = "Cathedral1";

  1266.             break;

  1267.         case 1:

  1268.             midiProg.name = "Cathedral2";

  1269.             break;

  1270.         case 2:

  1271.             midiProg.name = "Cathedral3";

  1272.             break;

  1273.         case 3:

  1274.             midiProg.name = "Hall1";

  1275.             break;

  1276.         case 4:

  1277.             midiProg.name = "Hall2";

  1278.             break;

  1279.         case 5:

  1280.             midiProg.name = "Room1";

  1281.             break;

  1282.         case 6:

  1283.             midiProg.name = "Room2";

  1284.             break;

  1285.         case 7:

  1286.             midiProg.name = "Basement";

  1287.             break;

  1288.         case 8:

  1289.             midiProg.name = "Tunnel";

  1290.             break;

  1291.         case 9:

  1292.             midiProg.name = "Echoed1";

  1293.             break;

  1294.         case 10:

  1295.             midiProg.name = "Echoed2";

  1296.             break;

  1297.         case 11:

  1298.             midiProg.name = "VeryLong1";

  1299.             break;

  1300.         case 12:

  1301.             midiProg.name = "VeryLong2";

  1302.             break;

  1303.         default:

  1304.             midiProg.name = nullptr;

  1305.             break;

  1306.         }

  1307. 

  1308.         return &midiProg;

  1309.     }

  1310. 

  1311.     // -------------------------------------------------------------------

  1312. 

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

  1314.     {

  1315.         delete fEffect;

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

  1317.     }

  1318. 

  1319.     PluginClassEND(FxReverbPlugin)

  1320.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1321. };

  1322. 

  1323. // -----------------------------------------------------------------------

  1324. 

  1325. static const NativePluginDescriptor fxAlienWahDesc = {

  1326.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1329.     /* audioIns  */ 2,

  1330.     /* audioOuts */ 2,

  1331.     /* midiIns   */ 0,

  1332.     /* midiOuts  */ 0,

  1333.     /* paramIns  */ 11-2,

  1334.     /* paramOuts */ 0,

  1335.     /* name      */ "ZynAlienWah",

  1336.     /* label     */ "zynalienwah",

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

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

  1339.     PluginDescriptorFILL(FxAlienWahPlugin)

  1340. };

  1341. 

  1342. static const NativePluginDescriptor fxChorusDesc = {

  1343.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1346.     /* audioIns  */ 2,

  1347.     /* audioOuts */ 2,

  1348.     /* midiIns   */ 0,

  1349.     /* midiOuts  */ 0,

  1350.     /* paramIns  */ 12-2,

  1351.     /* paramOuts */ 0,

  1352.     /* name      */ "ZynChorus",

  1353.     /* label     */ "zynchorus",

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

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

  1356.     PluginDescriptorFILL(FxChorusPlugin)

  1357. };

  1358. 

  1359. static const NativePluginDescriptor fxDistortionDesc = {

  1360.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1363.     /* audioIns  */ 2,

  1364.     /* audioOuts */ 2,

  1365.     /* midiIns   */ 0,

  1366.     /* midiOuts  */ 0,

  1367.     /* paramIns  */ 11-2,

  1368.     /* paramOuts */ 0,

  1369.     /* name      */ "ZynDistortion",

  1370.     /* label     */ "zyndistortion",

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

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

  1373.     PluginDescriptorFILL(FxDistortionPlugin)

  1374. };

  1375. 

  1376. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1377.     /* category  */ PLUGIN_CATEGORY_FILTER,

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

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

  1380.     /* audioIns  */ 2,

  1381.     /* audioOuts */ 2,

  1382.     /* midiIns   */ 0,

  1383.     /* midiOuts  */ 0,

  1384.     /* paramIns  */ 10-2,

  1385.     /* paramOuts */ 0,

  1386.     /* name      */ "ZynDynamicFilter",

  1387.     /* label     */ "zyndynamicfilter",

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

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

  1390.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1391. };

  1392. 

  1393. static const NativePluginDescriptor fxEchoDesc = {

  1394.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  1397.     /* audioIns  */ 2,

  1398.     /* audioOuts */ 2,

  1399.     /* midiIns   */ 0,

  1400.     /* midiOuts  */ 0,

  1401.     /* paramIns  */ 7-2,

  1402.     /* paramOuts */ 0,

  1403.     /* name      */ "ZynEcho",

  1404.     /* label     */ "zynecho",

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

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

  1407.     PluginDescriptorFILL(FxEchoPlugin)

  1408. };

  1409. 

  1410. static const NativePluginDescriptor fxPhaserDesc = {

  1411.     /* category  */ PLUGIN_CATEGORY_MODULATOR,

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

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

  1414.     /* audioIns  */ 2,

  1415.     /* audioOuts */ 2,

  1416.     /* midiIns   */ 0,

  1417.     /* midiOuts  */ 0,

  1418.     /* paramIns  */ 15-2,

  1419.     /* paramOuts */ 0,

  1420.     /* name      */ "ZynPhaser",

  1421.     /* label     */ "zynphaser",

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

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

  1424.     PluginDescriptorFILL(FxPhaserPlugin)

  1425. };

  1426. 

  1427. static const NativePluginDescriptor fxReverbDesc = {

  1428.     /* category  */ PLUGIN_CATEGORY_DELAY,

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

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

  1431.     /* audioIns  */ 2,

  1432.     /* audioOuts */ 2,

  1433.     /* midiIns   */ 0,

  1434.     /* midiOuts  */ 0,

  1435.     /* paramIns  */ 13-2,

  1436.     /* paramOuts */ 0,

  1437.     /* name      */ "ZynReverb",

  1438.     /* label     */ "zynreverb",

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

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

  1441.     PluginDescriptorFILL(FxReverbPlugin)

  1442. };

  1443. 

  1444. // -----------------------------------------------------------------------

  1445. 

  1446. CARLA_EXPORT

  1447. void carla_register_native_plugin_zynaddsubfx_fx()

  1448. {

  1449.     carla_register_native_plugin(&fxAlienWahDesc);

  1450.     carla_register_native_plugin(&fxChorusDesc);

  1451.     carla_register_native_plugin(&fxDistortionDesc);

  1452.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1453.     carla_register_native_plugin(&fxEchoDesc);

  1454.     carla_register_native_plugin(&fxPhaserDesc);

  1455.     carla_register_native_plugin(&fxReverbDesc);

  1456. }

  1457. 

  1458. // -----------------------------------------------------------------------