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

1450 lines
43KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaNative.hpp"

  19. #include "CarlaMathUtils.hpp"

  20. 

  21. #include "Effects/Alienwah.h"

  22. #include "Effects/Chorus.h"

  23. #include "Effects/Distorsion.h"

  24. #include "Effects/DynamicFilter.h"

  25. #include "Effects/Echo.h"

  26. #include "Effects/Phaser.h"

  27. #include "Effects/Reverb.h"

  28. #include "Misc/Allocator.h"

  29. 

  30. #include "juce_audio_basics.h"

  31. using juce::roundToIntAccurate;

  32. using juce::FloatVectorOperations;

  33. using juce::SharedResourcePointer;

  34. 

  35. // -----------------------------------------------------------------------

  36. 

  37. template<class ZynFX>

  38. class FxAbstractPlugin : public NativePluginClass

  39. {

  40. protected:

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

  42.         : NativePluginClass(host),

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

  44.           fProgramCount(programCount),

  45.           fBufferSize(getBufferSize()),

  46.           fSampleRate(getSampleRate()),

  47.           fEffect(nullptr),

  48.           efxoutl(nullptr),

  49.           efxoutr(nullptr)

  50.     {

  51.         const int ibufferSize(static_cast<int>(fBufferSize));

  52. 

  53.         efxoutl = new float[fBufferSize];

  54.         efxoutr = new float[fBufferSize];

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

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

  57. 

  58.         doReinit(true);

  59.     }

  60. 

  61.     ~FxAbstractPlugin() override

  62.     {

  63.         if (efxoutl != nullptr)

  64.         {

  65.             delete[] efxoutl;

  66.             efxoutl = nullptr;

  67.         }

  68. 

  69.         if (efxoutr != nullptr)

  70.         {

  71.             delete[] efxoutr;

  72.             efxoutr = nullptr;

  73.         }

  74. 

  75.         if (fEffect != nullptr)

  76.         {

  77.             delete fEffect;

  78.             fEffect = nullptr;

  79.         }

  80.     }

  81. 

  82.     // -------------------------------------------------------------------

  83.     // Plugin parameter calls

  84. 

  85.     uint32_t getParameterCount() const final

  86.     {

  87.         return fParamCount;

  88.     }

  89. 

  90.     float getParameterValue(const uint32_t index) const final

  91.     {

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

  93.     }

  94. 

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

  96.     // Plugin midi-program calls

  97. 

  98.     uint32_t getMidiProgramCount() const final

  99.     {

  100.         return fProgramCount;

  101.     }

  102. 

  103.     // -------------------------------------------------------------------

  104.     // Plugin state calls

  105. 

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

  107.     {

  108.         const int ivalue(roundToIntAccurate(carla_fixedValue(0.0f, 127.0f, value)));

  109. 

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

  111.     }

  112. 

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

  114.     {

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

  116. 

  117.         // reset volume and pan

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

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

  120.     }

  121. 

  122.     // -------------------------------------------------------------------

  123.     // Plugin process calls

  124. 

  125.     void activate() final

  126.     {

  127.         fEffect->cleanup();

  128.     }

  129. 

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

  131.     {

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

  133. 

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

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

  136.         else

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

  138. 

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

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

  141.         else

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

  143. 

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

  145. 

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

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

  148.     }

  149. 

  150.     // -------------------------------------------------------------------

  151.     // Plugin dispatcher

  152. 

  153.     void bufferSizeChanged(const uint32_t bufferSize) final

  154.     {

  155.         if (fBufferSize == bufferSize)

  156.             return;

  157. 

  158.         fBufferSize = bufferSize;

  159.         const int ibufferSize(static_cast<int>(fBufferSize));

  160. 

  161.         delete[] efxoutl;

  162.         delete[] efxoutr;

  163.         efxoutl = new float[bufferSize];

  164.         efxoutr = new float[bufferSize];

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

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

  167. 

  168.         doReinit(false);

  169.     }

  170. 

  171.     void sampleRateChanged(const double sampleRate) final

  172.     {

  173.         if (fSampleRate == sampleRate)

  174.             return;

  175. 

  176.         fSampleRate = sampleRate;

  177. 

  178.         doReinit(false);

  179.     }

  180. 

  181.     void doReinit(const bool firstInit)

  182.     {

  183.         uchar params[fParamCount];

  184. 

  185.         if (fEffect != nullptr)

  186.         {

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

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

  189. 

  190.             delete fEffect;

  191.         }

  192. 

  193.         EffectParams pars(fAllocator.getObject(), false, efxoutl, efxoutr, 0, static_cast<uint>(fSampleRate), static_cast<int>(fBufferSize));

  194.         fEffect = new ZynFX(pars);

  195. 

  196.         if (firstInit)

  197.         {

  198.             fEffect->setpreset(0);

  199.         }

  200.         else

  201.         {

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

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

  204.         }

  205. 

  206.         // reset volume and pan

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

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

  209.     }

  210. 

  211.     // -------------------------------------------------------------------

  212. 

  213.     const uint32_t fParamCount;

  214.     const uint32_t fProgramCount;

  215. 

  216.     uint32_t fBufferSize;

  217.     double   fSampleRate;

  218. 

  219.     Effect* fEffect;

  220.     float*  efxoutl;

  221.     float*  efxoutr;

  222. 

  223.     // FIXME - is this thread-safe?

  224.     SharedResourcePointer<Allocator> fAllocator;

  225. 

  226.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  227. };

  228. 

  229. // -----------------------------------------------------------------------

  230. 

  231. class FxAlienWahPlugin : public FxAbstractPlugin<Alienwah>

  232. {

  233. public:

  234.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

  235.         : FxAbstractPlugin(host, 11, 4) {}

  236. 

  237. protected:

  238.     // -------------------------------------------------------------------

  239.     // Plugin parameter calls

  240. 

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

  242.     {

  243.         if (index >= fParamCount)

  244.             return nullptr;

  245. 

  246.         static NativeParameter param;

  247.         static NativeParameterScalePoint scalePoints[2];

  248. 

  249.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  250. 

  251.         param.name = nullptr;

  252.         param.unit = nullptr;

  253.         param.ranges.def       = 1.0f;

  254.         param.ranges.min       = 0.0f;

  255.         param.ranges.max       = 127.0f;

  256.         param.ranges.step      = 1.0f;

  257.         param.ranges.stepSmall = 1.0f;

  258.         param.ranges.stepLarge = 20.0f;

  259.         param.scalePointCount  = 0;

  260.         param.scalePoints      = nullptr;

  261. 

  262.         switch (index)

  263.         {

  264.         case 0:

  265.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  266.             param.name = "LFO Frequency";

  267.             param.ranges.def = 70.0f;

  268.             break;

  269.         case 1:

  270.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  271.             param.name = "LFO Randomness";

  272.             param.ranges.def = 0.0f;

  273.             break;

  274.         case 2:

  275.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  276.             param.name = "LFO Type";

  277.             param.ranges.def = 0.0f;

  278.             param.ranges.max = 1.0f;

  279.             param.scalePointCount = 2;

  280.             param.scalePoints     = scalePoints;

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

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

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

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

  285.             break;

  286.         case 3:

  287.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  288.             param.name = "LFO Stereo";

  289.             param.ranges.def = 62.0f;

  290.             break;

  291.         case 4:

  292.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  293.             param.name = "Depth";

  294.             param.ranges.def = 60.0f;

  295.             break;

  296.         case 5:

  297.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  298.             param.name = "Feedback";

  299.             param.ranges.def = 105.0f;

  300.             break;

  301.         case 6:

  302.             param.name = "Delay";

  303.             param.ranges.def = 25.0f;

  304.             param.ranges.min = 1.0f;

  305.             param.ranges.max = 100.0f;

  306.             break;

  307.         case 7:

  308.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  310.             param.ranges.def = 0.0f;

  311.             break;

  312.         case 8:

  313.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  314.             param.name = "Phase";

  315.             param.ranges.def = 64.0f;

  316.             break;

  317.         }

  318. 

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

  320. 

  321.         return &param;

  322.     }

  323. 

  324.     // -------------------------------------------------------------------

  325.     // Plugin midi-program calls

  326. 

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

  328.     {

  329.         if (index >= fProgramCount)

  330.             return nullptr;

  331. 

  332.         static NativeMidiProgram midiProg;

  333. 

  334.         midiProg.bank    = 0;

  335.         midiProg.program = index;

  336. 

  337.         switch (index)

  338.         {

  339.         case 0:

  340.             midiProg.name = "AlienWah1";

  341.             break;

  342.         case 1:

  343.             midiProg.name = "AlienWah2";

  344.             break;

  345.         case 2:

  346.             midiProg.name = "AlienWah3";

  347.             break;

  348.         case 3:

  349.             midiProg.name = "AlienWah4";

  350.             break;

  351.         default:

  352.             midiProg.name = nullptr;

  353.             break;

  354.         }

  355. 

  356.         return &midiProg;

  357.     }

  358. 

  359.     // -------------------------------------------------------------------

  360. 

  361.     PluginClassEND(FxAlienWahPlugin)

  362.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  363. };

  364. 

  365. // -----------------------------------------------------------------------

  366. 

  367. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  368. {

  369. public:

  370.     FxChorusPlugin(const NativeHostDescriptor* const host)

  371.         : FxAbstractPlugin(host, 12, 10) {}

  372. 

  373. protected:

  374.     // -------------------------------------------------------------------

  375.     // Plugin parameter calls

  376. 

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

  378.     {

  379.         if (index >= fParamCount)

  380.             return nullptr;

  381. 

  382.         static NativeParameter param;

  383.         static NativeParameterScalePoint scalePoints[2];

  384. 

  385.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  386. 

  387.         param.name = nullptr;

  388.         param.unit = nullptr;

  389.         param.ranges.def       = 1.0f;

  390.         param.ranges.min       = 0.0f;

  391.         param.ranges.max       = 127.0f;

  392.         param.ranges.step      = 1.0f;

  393.         param.ranges.stepSmall = 1.0f;

  394.         param.ranges.stepLarge = 20.0f;

  395.         param.scalePointCount  = 0;

  396.         param.scalePoints      = nullptr;

  397. 

  398.         switch (index)

  399.         {

  400.         case 0:

  401.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  402.             param.name = "LFO Frequency";

  403.             param.ranges.def = 50.0f;

  404.             break;

  405.         case 1:

  406.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  407.             param.name = "LFO Randomness";

  408.             param.ranges.def = 0.0f;

  409.             break;

  410.         case 2:

  411.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  412.             param.name = "LFO Type";

  413.             param.ranges.def = 0.0f;

  414.             param.ranges.max = 1.0f;

  415.             param.scalePointCount = 2;

  416.             param.scalePoints     = scalePoints;

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

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

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

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

  421.             break;

  422.         case 3:

  423.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  424.             param.name = "LFO Stereo";

  425.             param.ranges.def = 90.0f;

  426.             break;

  427.         case 4:

  428.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  429.             param.name = "Depth";

  430.             param.ranges.def = 40.0f;

  431.             break;

  432.         case 5:

  433.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  434.             param.name = "Delay";

  435.             param.ranges.def = 85.0f;

  436.             break;

  437.         case 6:

  438.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  439.             param.name = "Feedback";

  440.             param.ranges.def = 64.0f;

  441.             break;

  442.         case 7:

  443.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  445.             param.ranges.def = 119.0f;

  446.             break;

  447.         case 8:

  448.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  449.             param.name = "Flange Mode";

  450.             param.ranges.def = 0.0f;

  451.             param.ranges.max = 1.0f;

  452.             break;

  453.         case 9:

  454.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  455.             param.name = "Subtract Output";

  456.             param.ranges.def = 0.0f;

  457.             param.ranges.max = 1.0f;

  458.             break;

  459.         }

  460. 

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

  462. 

  463.         return &param;

  464.     }

  465. 

  466.     // -------------------------------------------------------------------

  467.     // Plugin midi-program calls

  468. 

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

  470.     {

  471.         if (index >= fProgramCount)

  472.             return nullptr;

  473. 

  474.         static NativeMidiProgram midiProg;

  475. 

  476.         midiProg.bank    = 0;

  477.         midiProg.program = index;

  478. 

  479.         switch (index)

  480.         {

  481.         case 0:

  482.             midiProg.name = "Chorus1";

  483.             break;

  484.         case 1:

  485.             midiProg.name = "Chorus2";

  486.             break;

  487.         case 2:

  488.             midiProg.name = "Chorus3";

  489.             break;

  490.         case 3:

  491.             midiProg.name = "Celeste1";

  492.             break;

  493.         case 4:

  494.             midiProg.name = "Celeste2";

  495.             break;

  496.         case 5:

  497.             midiProg.name = "Flange1";

  498.             break;

  499.         case 6:

  500.             midiProg.name = "Flange2";

  501.             break;

  502.         case 7:

  503.             midiProg.name = "Flange3";

  504.             break;

  505.         case 8:

  506.             midiProg.name = "Flange4";

  507.             break;

  508.         case 9:

  509.             midiProg.name = "Flange5";

  510.             break;

  511.         default:

  512.             midiProg.name = nullptr;

  513.             break;

  514.         }

  515. 

  516.         return &midiProg;

  517.     }

  518. 

  519.     // -------------------------------------------------------------------

  520. 

  521.     PluginClassEND(FxChorusPlugin)

  522.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  523. };

  524. 

  525. // -----------------------------------------------------------------------

  526. 

  527. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  528. {

  529. public:

  530.     FxDistortionPlugin(const NativeHostDescriptor* const host)

  531.         : FxAbstractPlugin(host, 11, 6) {}

  532. 

  533. protected:

  534.     // -------------------------------------------------------------------

  535.     // Plugin parameter calls

  536. 

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

  538.     {

  539.         if (index >= fParamCount)

  540.             return nullptr;

  541. 

  542.         static NativeParameter param;

  543.         static NativeParameterScalePoint scalePoints[14];

  544. 

  545.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  546. 

  547.         param.name = nullptr;

  548.         param.unit = nullptr;

  549.         param.ranges.def       = 1.0f;

  550.         param.ranges.min       = 0.0f;

  551.         param.ranges.max       = 127.0f;

  552.         param.ranges.step      = 1.0f;

  553.         param.ranges.stepSmall = 1.0f;

  554.         param.ranges.stepLarge = 20.0f;

  555.         param.scalePointCount  = 0;

  556.         param.scalePoints      = nullptr;

  557. 

  558.         switch (index)

  559.         {

  560.         case 0:

  561.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  563.             param.ranges.def = 35.0f;

  564.             break;

  565.         case 1:

  566.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  567.             param.name = "Drive";

  568.             param.ranges.def = 56.0f;

  569.             break;

  570.         case 2:

  571.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  572.             param.name = "Level";

  573.             param.ranges.def = 70.0f;

  574.             break;

  575.         case 3:

  576.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  577.             param.name = "Type";

  578.             param.ranges.def = 0.0f;

  579.             param.ranges.max = 13.0f;

  580.             param.scalePointCount = 14;

  581.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  610.             break;

  611.         case 4:

  612.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  613.             param.name = "Negate";

  614.             param.ranges.def = 0.0f;

  615.             param.ranges.max = 1.0f;

  616.             break;

  617.         case 5:

  618.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  620.             param.ranges.def = 96.0f;

  621.             break;

  622.         case 6:

  623.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  625.             param.ranges.def = 0.0f;

  626.             break;

  627.         case 7:

  628.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  629.             param.name = "Stereo";

  630.             param.ranges.def = 0.0f;

  631.             param.ranges.max = 1.0f;

  632.             break;

  633.         case 8:

  634.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  636.             param.ranges.def = 0.0f;

  637.             param.ranges.max = 1.0f;

  638.             break;

  639.         }

  640. 

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

  642. 

  643.         return &param;

  644.     }

  645. 

  646.     // -------------------------------------------------------------------

  647.     // Plugin midi-program calls

  648. 

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

  650.     {

  651.         if (index >= fProgramCount)

  652.             return nullptr;

  653. 

  654.         static NativeMidiProgram midiProg;

  655. 

  656.         midiProg.bank    = 0;

  657.         midiProg.program = index;

  658. 

  659.         switch (index)

  660.         {

  661.         case 0:

  662.             midiProg.name = "Overdrive 1";

  663.             break;

  664.         case 1:

  665.             midiProg.name = "Overdrive 2";

  666.             break;

  667.         case 2:

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

  669.             break;

  670.         case 3:

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

  672.             break;

  673.         case 4:

  674.             midiProg.name = "Guitar Amp";

  675.             break;

  676.         case 5:

  677.             midiProg.name = "Quantisize";

  678.             break;

  679.         default:

  680.             midiProg.name = nullptr;

  681.             break;

  682.         }

  683. 

  684.         return &midiProg;

  685.     }

  686. 

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

  688. 

  689.     PluginClassEND(FxDistortionPlugin)

  690.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  691. };

  692. 

  693. // -----------------------------------------------------------------------

  694. 

  695. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  696. {

  697. public:

  698.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

  699.         : FxAbstractPlugin(host, 10, 5) {}

  700. 

  701. protected:

  702.     // -------------------------------------------------------------------

  703.     // Plugin parameter calls

  704. 

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

  706.     {

  707.         if (index >= fParamCount)

  708.             return nullptr;

  709. 

  710.         static NativeParameter param;

  711.         static NativeParameterScalePoint scalePoints[2];

  712. 

  713.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  714. 

  715.         param.name = nullptr;

  716.         param.unit = nullptr;

  717.         param.ranges.def       = 1.0f;

  718.         param.ranges.min       = 0.0f;

  719.         param.ranges.max       = 127.0f;

  720.         param.ranges.step      = 1.0f;

  721.         param.ranges.stepSmall = 1.0f;

  722.         param.ranges.stepLarge = 20.0f;

  723.         param.scalePointCount  = 0;

  724.         param.scalePoints      = nullptr;

  725. 

  726.         switch (index)

  727.         {

  728.         case 0:

  729.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  730.             param.name = "LFO Frequency";

  731.             param.ranges.def = 80.0f;

  732.             break;

  733.         case 1:

  734.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  735.             param.name = "LFO Randomness";

  736.             param.ranges.def = 0.0f;

  737.             break;

  738.         case 2:

  739.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  740.             param.name = "LFO Type";

  741.             param.ranges.def = 0.0f;

  742.             param.ranges.max = 1.0f;

  743.             param.scalePointCount = 2;

  744.             param.scalePoints     = scalePoints;

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

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

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

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

  749.             break;

  750.         case 3:

  751.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  752.             param.name = "LFO Stereo";

  753.             param.ranges.def = 64.0f;

  754.             break;

  755.         case 4:

  756.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  757.             param.name = "LFO Depth";

  758.             param.ranges.def = 0.0f;

  759.             break;

  760.         case 5:

  761.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  762.             param.name = "Amp sns";

  763.             param.ranges.def = 90.0f;

  764.             break;

  765.         case 6:

  766.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  768.             param.ranges.def = 0.0f;

  769.             param.ranges.max = 1.0f;

  770.             break;

  771.         case 7:

  772.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  773.             param.name = "Amp Smooth";

  774.             param.ranges.def = 60.0f;

  775.             break;

  776.         }

  777. 

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

  779. 

  780.         return &param;

  781.     }

  782. 

  783.     // -------------------------------------------------------------------

  784.     // Plugin midi-program calls

  785. 

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

  787.     {

  788.         if (index >= fProgramCount)

  789.             return nullptr;

  790. 

  791.         static NativeMidiProgram midiProg;

  792. 

  793.         midiProg.bank    = 0;

  794.         midiProg.program = index;

  795. 

  796.         switch (index)

  797.         {

  798.         case 0:

  799.             midiProg.name = "WahWah";

  800.             break;

  801.         case 1:

  802.             midiProg.name = "AutoWah";

  803.             break;

  804.         case 2:

  805.             midiProg.name = "Sweep";

  806.             break;

  807.         case 3:

  808.             midiProg.name = "VocalMorph1";

  809.             break;

  810.         case 4:

  811.             midiProg.name = "VocalMorph2";

  812.             break;

  813.         default:

  814.             midiProg.name = nullptr;

  815.             break;

  816.         }

  817. 

  818.         return &midiProg;

  819.     }

  820. 

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

  822. 

  823.     PluginClassEND(FxDynamicFilterPlugin)

  824.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  825. };

  826. 

  827. // -----------------------------------------------------------------------

  828. 

  829. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  830. {

  831. public:

  832.     FxEchoPlugin(const NativeHostDescriptor* const host)

  833.         : FxAbstractPlugin(host, 7, 9) {}

  834. 

  835. protected:

  836.     // -------------------------------------------------------------------

  837.     // Plugin parameter calls

  838. 

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

  840.     {

  841.         if (index >= fParamCount)

  842.             return nullptr;

  843. 

  844.         static NativeParameter param;

  845. 

  846.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  847. 

  848.         param.name = nullptr;

  849.         param.unit = nullptr;

  850.         param.ranges.def       = 1.0f;

  851.         param.ranges.min       = 0.0f;

  852.         param.ranges.max       = 127.0f;

  853.         param.ranges.step      = 1.0f;

  854.         param.ranges.stepSmall = 1.0f;

  855.         param.ranges.stepLarge = 20.0f;

  856.         param.scalePointCount  = 0;

  857.         param.scalePoints      = nullptr;

  858. 

  859.         switch (index)

  860.         {

  861.         case 0:

  862.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  863.             param.name = "Delay";

  864.             param.ranges.def = 35.0f;

  865.             break;

  866.         case 1:

  867.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  869.             param.ranges.def = 64.0f;

  870.             break;

  871.         case 2:

  872.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  874.             param.ranges.def = 30.0f;

  875.             break;

  876.         case 3:

  877.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  878.             param.name = "Feedback";

  879.             param.ranges.def = 59.0f;

  880.             break;

  881.         case 4:

  882.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  883.             param.name = "High Damp";

  884.             param.ranges.def = 0.0f;

  885.             break;

  886.         }

  887. 

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

  889. 

  890.         return &param;

  891.     }

  892. 

  893.     // -------------------------------------------------------------------

  894.     // Plugin midi-program calls

  895. 

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

  897.     {

  898.         if (index >= fProgramCount)

  899.             return nullptr;

  900. 

  901.         static NativeMidiProgram midiProg;

  902. 

  903.         midiProg.bank    = 0;

  904.         midiProg.program = index;

  905. 

  906.         switch (index)

  907.         {

  908.         case 0:

  909.             midiProg.name = "Echo 1";

  910.             break;

  911.         case 1:

  912.             midiProg.name = "Echo 2";

  913.             break;

  914.         case 2:

  915.             midiProg.name = "Echo 3";

  916.             break;

  917.         case 3:

  918.             midiProg.name = "Simple Echo";

  919.             break;

  920.         case 4:

  921.             midiProg.name = "Canyon";

  922.             break;

  923.         case 5:

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

  925.             break;

  926.         case 6:

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

  928.             break;

  929.         case 7:

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

  931.             break;

  932.         case 8:

  933.             midiProg.name = "Feedback Echo";

  934.             break;

  935.         default:

  936.             midiProg.name = nullptr;

  937.             break;

  938.         }

  939. 

  940.         return &midiProg;

  941.     }

  942. 

  943.     // -------------------------------------------------------------------

  944. 

  945.     PluginClassEND(FxEchoPlugin)

  946.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  947. };

  948. 

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

  950. 

  951. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  952. {

  953. public:

  954.     FxPhaserPlugin(const NativeHostDescriptor* const host)

  955.         : FxAbstractPlugin(host, 15, 12) {}

  956. 

  957. protected:

  958.     // -------------------------------------------------------------------

  959.     // Plugin parameter calls

  960. 

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

  962.     {

  963.         if (index >= fParamCount)

  964.             return nullptr;

  965. 

  966.         static NativeParameter param;

  967.         static NativeParameterScalePoint scalePoints[2];

  968. 

  969.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  970. 

  971.         param.name = nullptr;

  972.         param.unit = nullptr;

  973.         param.ranges.def       = 1.0f;

  974.         param.ranges.min       = 0.0f;

  975.         param.ranges.max       = 127.0f;

  976.         param.ranges.step      = 1.0f;

  977.         param.ranges.stepSmall = 1.0f;

  978.         param.ranges.stepLarge = 20.0f;

  979.         param.scalePointCount  = 0;

  980.         param.scalePoints      = nullptr;

  981. 

  982.         switch (index)

  983.         {

  984.         case 0:

  985.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  986.             param.name = "LFO Frequency";

  987.             param.ranges.def = 36.0f;

  988.             break;

  989.         case 1:

  990.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  991.             param.name = "LFO Randomness";

  992.             param.ranges.def = 0.0f;

  993.             break;

  994.         case 2:

  995.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  996.             param.name = "LFO Type";

  997.             param.ranges.def = 0.0f;

  998.             param.ranges.max = 1.0f;

  999.             param.scalePointCount = 2;

  1000.             param.scalePoints     = scalePoints;

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

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

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

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

  1005.             break;

  1006.         case 3:

  1007.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1008.             param.name = "LFO Stereo";

  1009.             param.ranges.def = 64.0f;

  1010.             break;

  1011.         case 4:

  1012.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1013.             param.name = "Depth";

  1014.             param.ranges.def = 110.0f;

  1015.             break;

  1016.         case 5:

  1017.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1018.             param.name = "Feedback";

  1019.             param.ranges.def = 64.0f;

  1020.             break;

  1021.         case 6:

  1022.             param.name = "Stages";

  1023.             param.ranges.def = 1.0f;

  1024.             param.ranges.min = 1.0f;

  1025.             param.ranges.max = 12.0f;

  1026.             break;

  1027.         case 7:

  1028.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1030.             param.ranges.def = 0.0f;

  1031.             break;

  1032.         case 8:

  1033.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1034.             param.name = "Subtract Output";

  1035.             param.ranges.def = 0.0f;

  1036.             param.ranges.max = 1.0f;

  1037.             break;

  1038.         case 9:

  1039.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1041.             param.ranges.def = 20.0f;

  1042.             break;

  1043.         case 10:

  1044.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1045.             param.name = "Hyper";

  1046.             param.ranges.def = 0.0f;

  1047.             param.ranges.max = 1.0f;

  1048.             break;

  1049.         case 11:

  1050.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1051.             param.name = "Distortion";

  1052.             param.ranges.def = 0.0f;

  1053.             break;

  1054.         case 12:

  1055.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1056.             param.name = "Analog";

  1057.             param.ranges.def = 0.0f;

  1058.             param.ranges.max = 1.0f;

  1059.             break;

  1060.         }

  1061. 

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

  1063. 

  1064.         return &param;

  1065.     }

  1066. 

  1067.     // -------------------------------------------------------------------

  1068.     // Plugin midi-program calls

  1069. 

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

  1071.     {

  1072.         if (index >= fProgramCount)

  1073.             return nullptr;

  1074. 

  1075.         static NativeMidiProgram midiProg;

  1076. 

  1077.         midiProg.bank    = 0;

  1078.         midiProg.program = index;

  1079. 

  1080.         switch (index)

  1081.         {

  1082.         case 0:

  1083.             midiProg.name = "Phaser 1";

  1084.             break;

  1085.         case 1:

  1086.             midiProg.name = "Phaser 2";

  1087.             break;

  1088.         case 2:

  1089.             midiProg.name = "Phaser 3";

  1090.             break;

  1091.         case 3:

  1092.             midiProg.name = "Phaser 4";

  1093.             break;

  1094.         case 4:

  1095.             midiProg.name = "Phaser 5";

  1096.             break;

  1097.         case 5:

  1098.             midiProg.name = "Phaser 6";

  1099.             break;

  1100.         case 6:

  1101.             midiProg.name = "APhaser 1";

  1102.             break;

  1103.         case 7:

  1104.             midiProg.name = "APhaser 2";

  1105.             break;

  1106.         case 8:

  1107.             midiProg.name = "APhaser 3";

  1108.             break;

  1109.         case 9:

  1110.             midiProg.name = "APhaser 4";

  1111.             break;

  1112.         case 10:

  1113.             midiProg.name = "APhaser 5";

  1114.             break;

  1115.         case 11:

  1116.             midiProg.name = "APhaser 6";

  1117.             break;

  1118.         default:

  1119.             midiProg.name = nullptr;

  1120.             break;

  1121.         }

  1122. 

  1123.         return &midiProg;

  1124.     }

  1125. 

  1126.     // -------------------------------------------------------------------

  1127. 

  1128.     PluginClassEND(FxPhaserPlugin)

  1129.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1130. };

  1131. 

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

  1133. 

  1134. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1135. {

  1136. public:

  1137.     FxReverbPlugin(const NativeHostDescriptor* const host)

  1138.         : FxAbstractPlugin(host, 13, 13) {}

  1139. 

  1140. protected:

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

  1142.     // Plugin parameter calls

  1143. 

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

  1145.     {

  1146.         if (index >= fParamCount)

  1147.             return nullptr;

  1148. 

  1149.         static NativeParameter param;

  1150.         static NativeParameterScalePoint scalePoints[3];

  1151. 

  1152.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1153. 

  1154.         param.name = nullptr;

  1155.         param.unit = nullptr;

  1156.         param.ranges.def       = 1.0f;

  1157.         param.ranges.min       = 0.0f;

  1158.         param.ranges.max       = 127.0f;

  1159.         param.ranges.step      = 1.0f;

  1160.         param.ranges.stepSmall = 1.0f;

  1161.         param.ranges.stepLarge = 20.0f;

  1162.         param.scalePointCount  = 0;

  1163.         param.scalePoints      = nullptr;

  1164. 

  1165.         switch (index)

  1166.         {

  1167.         case 0:

  1168.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1169.             param.name = "Time";

  1170.             param.ranges.def = 63.0f;

  1171.             break;

  1172.         case 1:

  1173.             param.name = "Delay";

  1174.             param.ranges.def = 24.0f;

  1175.             break;

  1176.         case 2:

  1177.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1178.             param.name = "Feedback";

  1179.             param.ranges.def = 0.0f;

  1180.             break;

  1181.         case 3:

  1182.             hints = 0x0;

  1183.             param.name = "bw";

  1184.             break;

  1185.         case 4:

  1186.             hints = 0x0;

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

  1188.             break;

  1189.         case 5:

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

  1191.             param.ranges.def = 85.0f;

  1192.             break;

  1193.         case 6:

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

  1195.             param.ranges.def = 5.0f;

  1196.             break;

  1197.         case 7:

  1198.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1199.             param.name = "Damp";

  1200.             param.ranges.def = 83.0f;

  1201.             param.ranges.min = 64.0f;

  1202.             break;

  1203.         case 8:

  1204.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1205.             param.name = "Type";

  1206.             param.ranges.def = 1.0f;

  1207.             param.ranges.max = 2.0f;

  1208.             param.scalePointCount = 3;

  1209.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1216.             break;

  1217.         case 9:

  1218.             param.name = "Room size";

  1219.             param.ranges.def = 64.0f;

  1220.             param.ranges.min = 1.0f;

  1221.             break;

  1222.         case 10:

  1223.             param.name = "Bandwidth";

  1224.             param.ranges.def = 20.0f;

  1225.             break;

  1226.         }

  1227. 

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

  1229. 

  1230.         return &param;

  1231.     }

  1232. 

  1233.     // -------------------------------------------------------------------

  1234.     // Plugin midi-program calls

  1235. 

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

  1237.     {

  1238.         if (index >= fProgramCount)

  1239.             return nullptr;

  1240. 

  1241.         static NativeMidiProgram midiProg;

  1242. 

  1243.         midiProg.bank    = 0;

  1244.         midiProg.program = index;

  1245. 

  1246.         switch (index)

  1247.         {

  1248.         case 0:

  1249.             midiProg.name = "Cathedral1";

  1250.             break;

  1251.         case 1:

  1252.             midiProg.name = "Cathedral2";

  1253.             break;

  1254.         case 2:

  1255.             midiProg.name = "Cathedral3";

  1256.             break;

  1257.         case 3:

  1258.             midiProg.name = "Hall1";

  1259.             break;

  1260.         case 4:

  1261.             midiProg.name = "Hall2";

  1262.             break;

  1263.         case 5:

  1264.             midiProg.name = "Room1";

  1265.             break;

  1266.         case 6:

  1267.             midiProg.name = "Room2";

  1268.             break;

  1269.         case 7:

  1270.             midiProg.name = "Basement";

  1271.             break;

  1272.         case 8:

  1273.             midiProg.name = "Tunnel";

  1274.             break;

  1275.         case 9:

  1276.             midiProg.name = "Echoed1";

  1277.             break;

  1278.         case 10:

  1279.             midiProg.name = "Echoed2";

  1280.             break;

  1281.         case 11:

  1282.             midiProg.name = "VeryLong1";

  1283.             break;

  1284.         case 12:

  1285.             midiProg.name = "VeryLong2";

  1286.             break;

  1287.         default:

  1288.             midiProg.name = nullptr;

  1289.             break;

  1290.         }

  1291. 

  1292.         return &midiProg;

  1293.     }

  1294. 

  1295.     // -------------------------------------------------------------------

  1296. 

  1297.     PluginClassEND(FxReverbPlugin)

  1298.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1299. };

  1300. 

  1301. // -----------------------------------------------------------------------

  1302. 

  1303. static const NativePluginDescriptor fxAlienWahDesc = {

  1304.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1306.                                                   |NATIVE_PLUGIN_USES_PANNING

  1307.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1309.     /* audioIns  */ 2,

  1310.     /* audioOuts */ 2,

  1311.     /* midiIns   */ 0,

  1312.     /* midiOuts  */ 0,

  1313.     /* paramIns  */ 11-2,

  1314.     /* paramOuts */ 0,

  1315.     /* name      */ "ZynAlienWah",

  1316.     /* label     */ "zynalienwah",

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

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

  1319.     PluginDescriptorFILL(FxAlienWahPlugin)

  1320. };

  1321. 

  1322. static const NativePluginDescriptor fxChorusDesc = {

  1323.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1325.                                                   |NATIVE_PLUGIN_USES_PANNING

  1326.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1328.     /* audioIns  */ 2,

  1329.     /* audioOuts */ 2,

  1330.     /* midiIns   */ 0,

  1331.     /* midiOuts  */ 0,

  1332.     /* paramIns  */ 12-2,

  1333.     /* paramOuts */ 0,

  1334.     /* name      */ "ZynChorus",

  1335.     /* label     */ "zynchorus",

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

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

  1338.     PluginDescriptorFILL(FxChorusPlugin)

  1339. };

  1340. 

  1341. static const NativePluginDescriptor fxDistortionDesc = {

  1342.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1344.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1346.     /* audioIns  */ 2,

  1347.     /* audioOuts */ 2,

  1348.     /* midiIns   */ 0,

  1349.     /* midiOuts  */ 0,

  1350.     /* paramIns  */ 11-2,

  1351.     /* paramOuts */ 0,

  1352.     /* name      */ "ZynDistortion",

  1353.     /* label     */ "zyndistortion",

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

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

  1356.     PluginDescriptorFILL(FxDistortionPlugin)

  1357. };

  1358. 

  1359. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1360.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1362.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1364.     /* audioIns  */ 2,

  1365.     /* audioOuts */ 2,

  1366.     /* midiIns   */ 0,

  1367.     /* midiOuts  */ 0,

  1368.     /* paramIns  */ 10-2,

  1369.     /* paramOuts */ 0,

  1370.     /* name      */ "ZynDynamicFilter",

  1371.     /* label     */ "zyndynamicfilter",

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

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

  1374.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1375. };

  1376. 

  1377. static const NativePluginDescriptor fxEchoDesc = {

  1378.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1380.                                                   |NATIVE_PLUGIN_USES_PANNING

  1381.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1383.     /* audioIns  */ 2,

  1384.     /* audioOuts */ 2,

  1385.     /* midiIns   */ 0,

  1386.     /* midiOuts  */ 0,

  1387.     /* paramIns  */ 7-2,

  1388.     /* paramOuts */ 0,

  1389.     /* name      */ "ZynEcho",

  1390.     /* label     */ "zynecho",

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

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

  1393.     PluginDescriptorFILL(FxEchoPlugin)

  1394. };

  1395. 

  1396. static const NativePluginDescriptor fxPhaserDesc = {

  1397.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1399.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1401.     /* audioIns  */ 2,

  1402.     /* audioOuts */ 2,

  1403.     /* midiIns   */ 0,

  1404.     /* midiOuts  */ 0,

  1405.     /* paramIns  */ 15-2,

  1406.     /* paramOuts */ 0,

  1407.     /* name      */ "ZynPhaser",

  1408.     /* label     */ "zynphaser",

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

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

  1411.     PluginDescriptorFILL(FxPhaserPlugin)

  1412. };

  1413. 

  1414. static const NativePluginDescriptor fxReverbDesc = {

  1415.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1417.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1419.     /* audioIns  */ 2,

  1420.     /* audioOuts */ 2,

  1421.     /* midiIns   */ 0,

  1422.     /* midiOuts  */ 0,

  1423.     /* paramIns  */ 13-2,

  1424.     /* paramOuts */ 0,

  1425.     /* name      */ "ZynReverb",

  1426.     /* label     */ "zynreverb",

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

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

  1429.     PluginDescriptorFILL(FxReverbPlugin)

  1430. };

  1431. 

  1432. // -----------------------------------------------------------------------

  1433. 

  1434. CARLA_EXPORT

  1435. void carla_register_native_plugin_zynaddsubfx_fx();

  1436. 

  1437. CARLA_EXPORT

  1438. void carla_register_native_plugin_zynaddsubfx_fx()

  1439. {

  1440.     carla_register_native_plugin(&fxAlienWahDesc);

  1441.     carla_register_native_plugin(&fxChorusDesc);

  1442.     carla_register_native_plugin(&fxDistortionDesc);

  1443.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1444.     carla_register_native_plugin(&fxEchoDesc);

  1445.     carla_register_native_plugin(&fxPhaserDesc);

  1446.     carla_register_native_plugin(&fxReverbDesc);

  1447. }

  1448. 

  1449. // -----------------------------------------------------------------------