falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
2956 Commits
17 Branches
940MB
Tree: c7cddfe5b0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c7cddfe5b0'
${ noResults }
Carla/source/native-plugins/zynaddsubfx-fx.cpp

1457 lines
44KB
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.           leakDetector_FxAbstractPlugin()

  51.     {

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

  53. 

  54.         efxoutl = new float[fBufferSize];

  55.         efxoutr = new float[fBufferSize];

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

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

  58. 

  59.         doReinit(true);

  60.     }

  61. 

  62.     ~FxAbstractPlugin() override

  63.     {

  64.         if (efxoutl != nullptr)

  65.         {

  66.             delete[] efxoutl;

  67.             efxoutl = nullptr;

  68.         }

  69. 

  70.         if (efxoutr != nullptr)

  71.         {

  72.             delete[] efxoutr;

  73.             efxoutr = nullptr;

  74.         }

  75. 

  76.         if (fEffect != nullptr)

  77.         {

  78.             delete fEffect;

  79.             fEffect = nullptr;

  80.         }

  81.     }

  82. 

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

  84.     // Plugin parameter calls

  85. 

  86.     uint32_t getParameterCount() const final

  87.     {

  88.         return fParamCount;

  89.     }

  90. 

  91.     float getParameterValue(const uint32_t index) const final

  92.     {

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

  94.     }

  95. 

  96.     // -------------------------------------------------------------------

  97.     // Plugin midi-program calls

  98. 

  99.     uint32_t getMidiProgramCount() const final

  100.     {

  101.         return fProgramCount;

  102.     }

  103. 

  104.     // -------------------------------------------------------------------

  105.     // Plugin state calls

  106. 

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

  108.     {

  109.         const int ivalue(roundToIntAccurate(carla_fixValue(0.0f, 127.0f, value)));

  110. 

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

  112.     }

  113. 

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

  115.     {

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

  117. 

  118.         // reset volume and pan

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

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

  121.     }

  122. 

  123.     // -------------------------------------------------------------------

  124.     // Plugin process calls

  125. 

  126.     void activate() final

  127.     {

  128.         fEffect->cleanup();

  129.     }

  130. 

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

  132.     {

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

  134. 

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

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

  137.         else

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

  139. 

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

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

  142.         else

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

  144. 

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

  146. 

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

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

  149.     }

  150. 

  151.     // -------------------------------------------------------------------

  152.     // Plugin dispatcher

  153. 

  154.     void bufferSizeChanged(const uint32_t bufferSize) final

  155.     {

  156.         if (fBufferSize == bufferSize)

  157.             return;

  158. 

  159.         fBufferSize = bufferSize;

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

  161. 

  162.         delete[] efxoutl;

  163.         delete[] efxoutr;

  164.         efxoutl = new float[bufferSize];

  165.         efxoutr = new float[bufferSize];

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

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

  168. 

  169.         doReinit(false);

  170.     }

  171. 

  172.     void sampleRateChanged(const double sampleRate) final

  173.     {

  174.         if (fSampleRate == sampleRate)

  175.             return;

  176. 

  177.         fSampleRate = sampleRate;

  178. 

  179.         doReinit(false);

  180.     }

  181. 

  182.     void doReinit(const bool firstInit)

  183.     {

  184.         uchar params[fParamCount];

  185. 

  186.         if (fEffect != nullptr)

  187.         {

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

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

  190. 

  191.             delete fEffect;

  192.         }

  193. 

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

  195.         fEffect = new ZynFX(pars);

  196. 

  197.         if (firstInit)

  198.         {

  199.             fEffect->setpreset(0);

  200.         }

  201.         else

  202.         {

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

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

  205.         }

  206. 

  207.         // reset volume and pan

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

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

  210.     }

  211. 

  212.     // -------------------------------------------------------------------

  213. 

  214.     const uint32_t fParamCount;

  215.     const uint32_t fProgramCount;

  216. 

  217.     uint32_t fBufferSize;

  218.     double   fSampleRate;

  219. 

  220.     Effect* fEffect;

  221.     float*  efxoutl;

  222.     float*  efxoutr;

  223. 

  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.           leakDetector_FxAlienWahPlugin() {}

  237. 

  238. protected:

  239.     // -------------------------------------------------------------------

  240.     // Plugin parameter calls

  241. 

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

  243.     {

  244.         if (index >= fParamCount)

  245.             return nullptr;

  246. 

  247.         static NativeParameter param;

  248.         static NativeParameterScalePoint scalePoints[2];

  249. 

  250.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  251. 

  252.         param.name = nullptr;

  253.         param.unit = nullptr;

  254.         param.ranges.def       = 1.0f;

  255.         param.ranges.min       = 0.0f;

  256.         param.ranges.max       = 127.0f;

  257.         param.ranges.step      = 1.0f;

  258.         param.ranges.stepSmall = 1.0f;

  259.         param.ranges.stepLarge = 20.0f;

  260.         param.scalePointCount  = 0;

  261.         param.scalePoints      = nullptr;

  262. 

  263.         switch (index)

  264.         {

  265.         case 0:

  266.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  267.             param.name = "LFO Frequency";

  268.             param.ranges.def = 70.0f;

  269.             break;

  270.         case 1:

  271.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  272.             param.name = "LFO Randomness";

  273.             param.ranges.def = 0.0f;

  274.             break;

  275.         case 2:

  276.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  277.             param.name = "LFO Type";

  278.             param.ranges.def = 0.0f;

  279.             param.ranges.max = 1.0f;

  280.             param.scalePointCount = 2;

  281.             param.scalePoints     = scalePoints;

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

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

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

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

  286.             break;

  287.         case 3:

  288.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  289.             param.name = "LFO Stereo";

  290.             param.ranges.def = 62.0f;

  291.             break;

  292.         case 4:

  293.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  294.             param.name = "Depth";

  295.             param.ranges.def = 60.0f;

  296.             break;

  297.         case 5:

  298.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  299.             param.name = "Feedback";

  300.             param.ranges.def = 105.0f;

  301.             break;

  302.         case 6:

  303.             param.name = "Delay";

  304.             param.ranges.def = 25.0f;

  305.             param.ranges.min = 1.0f;

  306.             param.ranges.max = 100.0f;

  307.             break;

  308.         case 7:

  309.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  311.             param.ranges.def = 0.0f;

  312.             break;

  313.         case 8:

  314.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  315.             param.name = "Phase";

  316.             param.ranges.def = 64.0f;

  317.             break;

  318.         }

  319. 

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

  321. 

  322.         return &param;

  323.     }

  324. 

  325.     // -------------------------------------------------------------------

  326.     // Plugin midi-program calls

  327. 

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

  329.     {

  330.         if (index >= fProgramCount)

  331.             return nullptr;

  332. 

  333.         static NativeMidiProgram midiProg;

  334. 

  335.         midiProg.bank    = 0;

  336.         midiProg.program = index;

  337. 

  338.         switch (index)

  339.         {

  340.         case 0:

  341.             midiProg.name = "AlienWah1";

  342.             break;

  343.         case 1:

  344.             midiProg.name = "AlienWah2";

  345.             break;

  346.         case 2:

  347.             midiProg.name = "AlienWah3";

  348.             break;

  349.         case 3:

  350.             midiProg.name = "AlienWah4";

  351.             break;

  352.         default:

  353.             midiProg.name = nullptr;

  354.             break;

  355.         }

  356. 

  357.         return &midiProg;

  358.     }

  359. 

  360.     // -------------------------------------------------------------------

  361. 

  362.     PluginClassEND(FxAlienWahPlugin)

  363.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  364. };

  365. 

  366. // -----------------------------------------------------------------------

  367. 

  368. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  369. {

  370. public:

  371.     FxChorusPlugin(const NativeHostDescriptor* const host)

  372.         : FxAbstractPlugin(host, 12, 10),

  373.           leakDetector_FxChorusPlugin() {}

  374. 

  375. protected:

  376.     // -------------------------------------------------------------------

  377.     // Plugin parameter calls

  378. 

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

  380.     {

  381.         if (index >= fParamCount)

  382.             return nullptr;

  383. 

  384.         static NativeParameter param;

  385.         static NativeParameterScalePoint scalePoints[2];

  386. 

  387.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  388. 

  389.         param.name = nullptr;

  390.         param.unit = nullptr;

  391.         param.ranges.def       = 1.0f;

  392.         param.ranges.min       = 0.0f;

  393.         param.ranges.max       = 127.0f;

  394.         param.ranges.step      = 1.0f;

  395.         param.ranges.stepSmall = 1.0f;

  396.         param.ranges.stepLarge = 20.0f;

  397.         param.scalePointCount  = 0;

  398.         param.scalePoints      = nullptr;

  399. 

  400.         switch (index)

  401.         {

  402.         case 0:

  403.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  404.             param.name = "LFO Frequency";

  405.             param.ranges.def = 50.0f;

  406.             break;

  407.         case 1:

  408.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  409.             param.name = "LFO Randomness";

  410.             param.ranges.def = 0.0f;

  411.             break;

  412.         case 2:

  413.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  414.             param.name = "LFO Type";

  415.             param.ranges.def = 0.0f;

  416.             param.ranges.max = 1.0f;

  417.             param.scalePointCount = 2;

  418.             param.scalePoints     = scalePoints;

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

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

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

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

  423.             break;

  424.         case 3:

  425.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  426.             param.name = "LFO Stereo";

  427.             param.ranges.def = 90.0f;

  428.             break;

  429.         case 4:

  430.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  431.             param.name = "Depth";

  432.             param.ranges.def = 40.0f;

  433.             break;

  434.         case 5:

  435.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  436.             param.name = "Delay";

  437.             param.ranges.def = 85.0f;

  438.             break;

  439.         case 6:

  440.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  441.             param.name = "Feedback";

  442.             param.ranges.def = 64.0f;

  443.             break;

  444.         case 7:

  445.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  447.             param.ranges.def = 119.0f;

  448.             break;

  449.         case 8:

  450.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  451.             param.name = "Flange Mode";

  452.             param.ranges.def = 0.0f;

  453.             param.ranges.max = 1.0f;

  454.             break;

  455.         case 9:

  456.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  457.             param.name = "Subtract Output";

  458.             param.ranges.def = 0.0f;

  459.             param.ranges.max = 1.0f;

  460.             break;

  461.         }

  462. 

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

  464. 

  465.         return &param;

  466.     }

  467. 

  468.     // -------------------------------------------------------------------

  469.     // Plugin midi-program calls

  470. 

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

  472.     {

  473.         if (index >= fProgramCount)

  474.             return nullptr;

  475. 

  476.         static NativeMidiProgram midiProg;

  477. 

  478.         midiProg.bank    = 0;

  479.         midiProg.program = index;

  480. 

  481.         switch (index)

  482.         {

  483.         case 0:

  484.             midiProg.name = "Chorus1";

  485.             break;

  486.         case 1:

  487.             midiProg.name = "Chorus2";

  488.             break;

  489.         case 2:

  490.             midiProg.name = "Chorus3";

  491.             break;

  492.         case 3:

  493.             midiProg.name = "Celeste1";

  494.             break;

  495.         case 4:

  496.             midiProg.name = "Celeste2";

  497.             break;

  498.         case 5:

  499.             midiProg.name = "Flange1";

  500.             break;

  501.         case 6:

  502.             midiProg.name = "Flange2";

  503.             break;

  504.         case 7:

  505.             midiProg.name = "Flange3";

  506.             break;

  507.         case 8:

  508.             midiProg.name = "Flange4";

  509.             break;

  510.         case 9:

  511.             midiProg.name = "Flange5";

  512.             break;

  513.         default:

  514.             midiProg.name = nullptr;

  515.             break;

  516.         }

  517. 

  518.         return &midiProg;

  519.     }

  520. 

  521.     // -------------------------------------------------------------------

  522. 

  523.     PluginClassEND(FxChorusPlugin)

  524.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  525. };

  526. 

  527. // -----------------------------------------------------------------------

  528. 

  529. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  530. {

  531. public:

  532.     FxDistortionPlugin(const NativeHostDescriptor* const host)

  533.         : FxAbstractPlugin(host, 11, 6),

  534.           leakDetector_FxDistortionPlugin() {}

  535. 

  536. protected:

  537.     // -------------------------------------------------------------------

  538.     // Plugin parameter calls

  539. 

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

  541.     {

  542.         if (index >= fParamCount)

  543.             return nullptr;

  544. 

  545.         static NativeParameter param;

  546.         static NativeParameterScalePoint scalePoints[14];

  547. 

  548.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  549. 

  550.         param.name = nullptr;

  551.         param.unit = nullptr;

  552.         param.ranges.def       = 1.0f;

  553.         param.ranges.min       = 0.0f;

  554.         param.ranges.max       = 127.0f;

  555.         param.ranges.step      = 1.0f;

  556.         param.ranges.stepSmall = 1.0f;

  557.         param.ranges.stepLarge = 20.0f;

  558.         param.scalePointCount  = 0;

  559.         param.scalePoints      = nullptr;

  560. 

  561.         switch (index)

  562.         {

  563.         case 0:

  564.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  566.             param.ranges.def = 35.0f;

  567.             break;

  568.         case 1:

  569.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  570.             param.name = "Drive";

  571.             param.ranges.def = 56.0f;

  572.             break;

  573.         case 2:

  574.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  575.             param.name = "Level";

  576.             param.ranges.def = 70.0f;

  577.             break;

  578.         case 3:

  579.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  580.             param.name = "Type";

  581.             param.ranges.def = 0.0f;

  582.             param.ranges.max = 13.0f;

  583.             param.scalePointCount = 14;

  584.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  613.             break;

  614.         case 4:

  615.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  616.             param.name = "Negate";

  617.             param.ranges.def = 0.0f;

  618.             param.ranges.max = 1.0f;

  619.             break;

  620.         case 5:

  621.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  623.             param.ranges.def = 96.0f;

  624.             break;

  625.         case 6:

  626.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  628.             param.ranges.def = 0.0f;

  629.             break;

  630.         case 7:

  631.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  632.             param.name = "Stereo";

  633.             param.ranges.def = 0.0f;

  634.             param.ranges.max = 1.0f;

  635.             break;

  636.         case 8:

  637.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  639.             param.ranges.def = 0.0f;

  640.             param.ranges.max = 1.0f;

  641.             break;

  642.         }

  643. 

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

  645. 

  646.         return &param;

  647.     }

  648. 

  649.     // -------------------------------------------------------------------

  650.     // Plugin midi-program calls

  651. 

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

  653.     {

  654.         if (index >= fProgramCount)

  655.             return nullptr;

  656. 

  657.         static NativeMidiProgram midiProg;

  658. 

  659.         midiProg.bank    = 0;

  660.         midiProg.program = index;

  661. 

  662.         switch (index)

  663.         {

  664.         case 0:

  665.             midiProg.name = "Overdrive 1";

  666.             break;

  667.         case 1:

  668.             midiProg.name = "Overdrive 2";

  669.             break;

  670.         case 2:

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

  672.             break;

  673.         case 3:

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

  675.             break;

  676.         case 4:

  677.             midiProg.name = "Guitar Amp";

  678.             break;

  679.         case 5:

  680.             midiProg.name = "Quantisize";

  681.             break;

  682.         default:

  683.             midiProg.name = nullptr;

  684.             break;

  685.         }

  686. 

  687.         return &midiProg;

  688.     }

  689. 

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

  691. 

  692.     PluginClassEND(FxDistortionPlugin)

  693.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  694. };

  695. 

  696. // -----------------------------------------------------------------------

  697. 

  698. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  699. {

  700. public:

  701.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

  702.         : FxAbstractPlugin(host, 10, 5),

  703.           leakDetector_FxDynamicFilterPlugin() {}

  704. 

  705. protected:

  706.     // -------------------------------------------------------------------

  707.     // Plugin parameter calls

  708. 

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

  710.     {

  711.         if (index >= fParamCount)

  712.             return nullptr;

  713. 

  714.         static NativeParameter param;

  715.         static NativeParameterScalePoint scalePoints[2];

  716. 

  717.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  718. 

  719.         param.name = nullptr;

  720.         param.unit = nullptr;

  721.         param.ranges.def       = 1.0f;

  722.         param.ranges.min       = 0.0f;

  723.         param.ranges.max       = 127.0f;

  724.         param.ranges.step      = 1.0f;

  725.         param.ranges.stepSmall = 1.0f;

  726.         param.ranges.stepLarge = 20.0f;

  727.         param.scalePointCount  = 0;

  728.         param.scalePoints      = nullptr;

  729. 

  730.         switch (index)

  731.         {

  732.         case 0:

  733.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  734.             param.name = "LFO Frequency";

  735.             param.ranges.def = 80.0f;

  736.             break;

  737.         case 1:

  738.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  739.             param.name = "LFO Randomness";

  740.             param.ranges.def = 0.0f;

  741.             break;

  742.         case 2:

  743.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  744.             param.name = "LFO Type";

  745.             param.ranges.def = 0.0f;

  746.             param.ranges.max = 1.0f;

  747.             param.scalePointCount = 2;

  748.             param.scalePoints     = scalePoints;

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

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

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

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

  753.             break;

  754.         case 3:

  755.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  756.             param.name = "LFO Stereo";

  757.             param.ranges.def = 64.0f;

  758.             break;

  759.         case 4:

  760.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  761.             param.name = "LFO Depth";

  762.             param.ranges.def = 0.0f;

  763.             break;

  764.         case 5:

  765.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  766.             param.name = "Amp sns";

  767.             param.ranges.def = 90.0f;

  768.             break;

  769.         case 6:

  770.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  772.             param.ranges.def = 0.0f;

  773.             param.ranges.max = 1.0f;

  774.             break;

  775.         case 7:

  776.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  777.             param.name = "Amp Smooth";

  778.             param.ranges.def = 60.0f;

  779.             break;

  780.         }

  781. 

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

  783. 

  784.         return &param;

  785.     }

  786. 

  787.     // -------------------------------------------------------------------

  788.     // Plugin midi-program calls

  789. 

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

  791.     {

  792.         if (index >= fProgramCount)

  793.             return nullptr;

  794. 

  795.         static NativeMidiProgram midiProg;

  796. 

  797.         midiProg.bank    = 0;

  798.         midiProg.program = index;

  799. 

  800.         switch (index)

  801.         {

  802.         case 0:

  803.             midiProg.name = "WahWah";

  804.             break;

  805.         case 1:

  806.             midiProg.name = "AutoWah";

  807.             break;

  808.         case 2:

  809.             midiProg.name = "Sweep";

  810.             break;

  811.         case 3:

  812.             midiProg.name = "VocalMorph1";

  813.             break;

  814.         case 4:

  815.             midiProg.name = "VocalMorph2";

  816.             break;

  817.         default:

  818.             midiProg.name = nullptr;

  819.             break;

  820.         }

  821. 

  822.         return &midiProg;

  823.     }

  824. 

  825.     // -------------------------------------------------------------------

  826. 

  827.     PluginClassEND(FxDynamicFilterPlugin)

  828.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  829. };

  830. 

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

  832. 

  833. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  834. {

  835. public:

  836.     FxEchoPlugin(const NativeHostDescriptor* const host)

  837.         : FxAbstractPlugin(host, 7, 9),

  838.           leakDetector_FxEchoPlugin() {}

  839. 

  840. protected:

  841.     // -------------------------------------------------------------------

  842.     // Plugin parameter calls

  843. 

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

  845.     {

  846.         if (index >= fParamCount)

  847.             return nullptr;

  848. 

  849.         static NativeParameter param;

  850. 

  851.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  852. 

  853.         param.name = nullptr;

  854.         param.unit = nullptr;

  855.         param.ranges.def       = 1.0f;

  856.         param.ranges.min       = 0.0f;

  857.         param.ranges.max       = 127.0f;

  858.         param.ranges.step      = 1.0f;

  859.         param.ranges.stepSmall = 1.0f;

  860.         param.ranges.stepLarge = 20.0f;

  861.         param.scalePointCount  = 0;

  862.         param.scalePoints      = nullptr;

  863. 

  864.         switch (index)

  865.         {

  866.         case 0:

  867.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  868.             param.name = "Delay";

  869.             param.ranges.def = 35.0f;

  870.             break;

  871.         case 1:

  872.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  874.             param.ranges.def = 64.0f;

  875.             break;

  876.         case 2:

  877.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  879.             param.ranges.def = 30.0f;

  880.             break;

  881.         case 3:

  882.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  883.             param.name = "Feedback";

  884.             param.ranges.def = 59.0f;

  885.             break;

  886.         case 4:

  887.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  888.             param.name = "High Damp";

  889.             param.ranges.def = 0.0f;

  890.             break;

  891.         }

  892. 

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

  894. 

  895.         return &param;

  896.     }

  897. 

  898.     // -------------------------------------------------------------------

  899.     // Plugin midi-program calls

  900. 

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

  902.     {

  903.         if (index >= fProgramCount)

  904.             return nullptr;

  905. 

  906.         static NativeMidiProgram midiProg;

  907. 

  908.         midiProg.bank    = 0;

  909.         midiProg.program = index;

  910. 

  911.         switch (index)

  912.         {

  913.         case 0:

  914.             midiProg.name = "Echo 1";

  915.             break;

  916.         case 1:

  917.             midiProg.name = "Echo 2";

  918.             break;

  919.         case 2:

  920.             midiProg.name = "Echo 3";

  921.             break;

  922.         case 3:

  923.             midiProg.name = "Simple Echo";

  924.             break;

  925.         case 4:

  926.             midiProg.name = "Canyon";

  927.             break;

  928.         case 5:

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

  930.             break;

  931.         case 6:

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

  933.             break;

  934.         case 7:

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

  936.             break;

  937.         case 8:

  938.             midiProg.name = "Feedback Echo";

  939.             break;

  940.         default:

  941.             midiProg.name = nullptr;

  942.             break;

  943.         }

  944. 

  945.         return &midiProg;

  946.     }

  947. 

  948.     // -------------------------------------------------------------------

  949. 

  950.     PluginClassEND(FxEchoPlugin)

  951.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  952. };

  953. 

  954. // -----------------------------------------------------------------------

  955. 

  956. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  957. {

  958. public:

  959.     FxPhaserPlugin(const NativeHostDescriptor* const host)

  960.         : FxAbstractPlugin(host, 15, 12),

  961.           leakDetector_FxPhaserPlugin() {}

  962. 

  963. protected:

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

  965.     // Plugin parameter calls

  966. 

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

  968.     {

  969.         if (index >= fParamCount)

  970.             return nullptr;

  971. 

  972.         static NativeParameter param;

  973.         static NativeParameterScalePoint scalePoints[2];

  974. 

  975.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  976. 

  977.         param.name = nullptr;

  978.         param.unit = nullptr;

  979.         param.ranges.def       = 1.0f;

  980.         param.ranges.min       = 0.0f;

  981.         param.ranges.max       = 127.0f;

  982.         param.ranges.step      = 1.0f;

  983.         param.ranges.stepSmall = 1.0f;

  984.         param.ranges.stepLarge = 20.0f;

  985.         param.scalePointCount  = 0;

  986.         param.scalePoints      = nullptr;

  987. 

  988.         switch (index)

  989.         {

  990.         case 0:

  991.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  992.             param.name = "LFO Frequency";

  993.             param.ranges.def = 36.0f;

  994.             break;

  995.         case 1:

  996.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  997.             param.name = "LFO Randomness";

  998.             param.ranges.def = 0.0f;

  999.             break;

  1000.         case 2:

  1001.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1002.             param.name = "LFO Type";

  1003.             param.ranges.def = 0.0f;

  1004.             param.ranges.max = 1.0f;

  1005.             param.scalePointCount = 2;

  1006.             param.scalePoints     = scalePoints;

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

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

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

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

  1011.             break;

  1012.         case 3:

  1013.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1014.             param.name = "LFO Stereo";

  1015.             param.ranges.def = 64.0f;

  1016.             break;

  1017.         case 4:

  1018.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1019.             param.name = "Depth";

  1020.             param.ranges.def = 110.0f;

  1021.             break;

  1022.         case 5:

  1023.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1024.             param.name = "Feedback";

  1025.             param.ranges.def = 64.0f;

  1026.             break;

  1027.         case 6:

  1028.             param.name = "Stages";

  1029.             param.ranges.def = 1.0f;

  1030.             param.ranges.min = 1.0f;

  1031.             param.ranges.max = 12.0f;

  1032.             break;

  1033.         case 7:

  1034.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1036.             param.ranges.def = 0.0f;

  1037.             break;

  1038.         case 8:

  1039.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1040.             param.name = "Subtract Output";

  1041.             param.ranges.def = 0.0f;

  1042.             param.ranges.max = 1.0f;

  1043.             break;

  1044.         case 9:

  1045.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1047.             param.ranges.def = 20.0f;

  1048.             break;

  1049.         case 10:

  1050.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1051.             param.name = "Hyper";

  1052.             param.ranges.def = 0.0f;

  1053.             param.ranges.max = 1.0f;

  1054.             break;

  1055.         case 11:

  1056.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1057.             param.name = "Distortion";

  1058.             param.ranges.def = 0.0f;

  1059.             break;

  1060.         case 12:

  1061.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1062.             param.name = "Analog";

  1063.             param.ranges.def = 0.0f;

  1064.             param.ranges.max = 1.0f;

  1065.             break;

  1066.         }

  1067. 

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

  1069. 

  1070.         return &param;

  1071.     }

  1072. 

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

  1074.     // Plugin midi-program calls

  1075. 

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

  1077.     {

  1078.         if (index >= fProgramCount)

  1079.             return nullptr;

  1080. 

  1081.         static NativeMidiProgram midiProg;

  1082. 

  1083.         midiProg.bank    = 0;

  1084.         midiProg.program = index;

  1085. 

  1086.         switch (index)

  1087.         {

  1088.         case 0:

  1089.             midiProg.name = "Phaser 1";

  1090.             break;

  1091.         case 1:

  1092.             midiProg.name = "Phaser 2";

  1093.             break;

  1094.         case 2:

  1095.             midiProg.name = "Phaser 3";

  1096.             break;

  1097.         case 3:

  1098.             midiProg.name = "Phaser 4";

  1099.             break;

  1100.         case 4:

  1101.             midiProg.name = "Phaser 5";

  1102.             break;

  1103.         case 5:

  1104.             midiProg.name = "Phaser 6";

  1105.             break;

  1106.         case 6:

  1107.             midiProg.name = "APhaser 1";

  1108.             break;

  1109.         case 7:

  1110.             midiProg.name = "APhaser 2";

  1111.             break;

  1112.         case 8:

  1113.             midiProg.name = "APhaser 3";

  1114.             break;

  1115.         case 9:

  1116.             midiProg.name = "APhaser 4";

  1117.             break;

  1118.         case 10:

  1119.             midiProg.name = "APhaser 5";

  1120.             break;

  1121.         case 11:

  1122.             midiProg.name = "APhaser 6";

  1123.             break;

  1124.         default:

  1125.             midiProg.name = nullptr;

  1126.             break;

  1127.         }

  1128. 

  1129.         return &midiProg;

  1130.     }

  1131. 

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

  1133. 

  1134.     PluginClassEND(FxPhaserPlugin)

  1135.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1136. };

  1137. 

  1138. // -----------------------------------------------------------------------

  1139. 

  1140. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1141. {

  1142. public:

  1143.     FxReverbPlugin(const NativeHostDescriptor* const host)

  1144.         : FxAbstractPlugin(host, 13, 13),

  1145.           leakDetector_FxReverbPlugin() {}

  1146. 

  1147. protected:

  1148.     // -------------------------------------------------------------------

  1149.     // Plugin parameter calls

  1150. 

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

  1152.     {

  1153.         if (index >= fParamCount)

  1154.             return nullptr;

  1155. 

  1156.         static NativeParameter param;

  1157.         static NativeParameterScalePoint scalePoints[3];

  1158. 

  1159.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1160. 

  1161.         param.name = nullptr;

  1162.         param.unit = nullptr;

  1163.         param.ranges.def       = 1.0f;

  1164.         param.ranges.min       = 0.0f;

  1165.         param.ranges.max       = 127.0f;

  1166.         param.ranges.step      = 1.0f;

  1167.         param.ranges.stepSmall = 1.0f;

  1168.         param.ranges.stepLarge = 20.0f;

  1169.         param.scalePointCount  = 0;

  1170.         param.scalePoints      = nullptr;

  1171. 

  1172.         switch (index)

  1173.         {

  1174.         case 0:

  1175.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1176.             param.name = "Time";

  1177.             param.ranges.def = 63.0f;

  1178.             break;

  1179.         case 1:

  1180.             param.name = "Delay";

  1181.             param.ranges.def = 24.0f;

  1182.             break;

  1183.         case 2:

  1184.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1185.             param.name = "Feedback";

  1186.             param.ranges.def = 0.0f;

  1187.             break;

  1188.         case 3:

  1189.             hints = 0x0;

  1190.             param.name = "bw";

  1191.             break;

  1192.         case 4:

  1193.             hints = 0x0;

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

  1195.             break;

  1196.         case 5:

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

  1198.             param.ranges.def = 85.0f;

  1199.             break;

  1200.         case 6:

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

  1202.             param.ranges.def = 5.0f;

  1203.             break;

  1204.         case 7:

  1205.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1206.             param.name = "Damp";

  1207.             param.ranges.def = 83.0f;

  1208.             param.ranges.min = 64.0f;

  1209.             break;

  1210.         case 8:

  1211.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1212.             param.name = "Type";

  1213.             param.ranges.def = 1.0f;

  1214.             param.ranges.max = 2.0f;

  1215.             param.scalePointCount = 3;

  1216.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1223.             break;

  1224.         case 9:

  1225.             param.name = "Room size";

  1226.             param.ranges.def = 64.0f;

  1227.             param.ranges.min = 1.0f;

  1228.             break;

  1229.         case 10:

  1230.             param.name = "Bandwidth";

  1231.             param.ranges.def = 20.0f;

  1232.             break;

  1233.         }

  1234. 

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

  1236. 

  1237.         return &param;

  1238.     }

  1239. 

  1240.     // -------------------------------------------------------------------

  1241.     // Plugin midi-program calls

  1242. 

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

  1244.     {

  1245.         if (index >= fProgramCount)

  1246.             return nullptr;

  1247. 

  1248.         static NativeMidiProgram midiProg;

  1249. 

  1250.         midiProg.bank    = 0;

  1251.         midiProg.program = index;

  1252. 

  1253.         switch (index)

  1254.         {

  1255.         case 0:

  1256.             midiProg.name = "Cathedral1";

  1257.             break;

  1258.         case 1:

  1259.             midiProg.name = "Cathedral2";

  1260.             break;

  1261.         case 2:

  1262.             midiProg.name = "Cathedral3";

  1263.             break;

  1264.         case 3:

  1265.             midiProg.name = "Hall1";

  1266.             break;

  1267.         case 4:

  1268.             midiProg.name = "Hall2";

  1269.             break;

  1270.         case 5:

  1271.             midiProg.name = "Room1";

  1272.             break;

  1273.         case 6:

  1274.             midiProg.name = "Room2";

  1275.             break;

  1276.         case 7:

  1277.             midiProg.name = "Basement";

  1278.             break;

  1279.         case 8:

  1280.             midiProg.name = "Tunnel";

  1281.             break;

  1282.         case 9:

  1283.             midiProg.name = "Echoed1";

  1284.             break;

  1285.         case 10:

  1286.             midiProg.name = "Echoed2";

  1287.             break;

  1288.         case 11:

  1289.             midiProg.name = "VeryLong1";

  1290.             break;

  1291.         case 12:

  1292.             midiProg.name = "VeryLong2";

  1293.             break;

  1294.         default:

  1295.             midiProg.name = nullptr;

  1296.             break;

  1297.         }

  1298. 

  1299.         return &midiProg;

  1300.     }

  1301. 

  1302.     // -------------------------------------------------------------------

  1303. 

  1304.     PluginClassEND(FxReverbPlugin)

  1305.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1306. };

  1307. 

  1308. // -----------------------------------------------------------------------

  1309. 

  1310. static const NativePluginDescriptor fxAlienWahDesc = {

  1311.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1313.                                                   |NATIVE_PLUGIN_USES_PANNING

  1314.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1316.     /* audioIns  */ 2,

  1317.     /* audioOuts */ 2,

  1318.     /* midiIns   */ 0,

  1319.     /* midiOuts  */ 0,

  1320.     /* paramIns  */ 11-2,

  1321.     /* paramOuts */ 0,

  1322.     /* name      */ "ZynAlienWah",

  1323.     /* label     */ "zynalienwah",

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

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

  1326.     PluginDescriptorFILL(FxAlienWahPlugin)

  1327. };

  1328. 

  1329. static const NativePluginDescriptor fxChorusDesc = {

  1330.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1332.                                                   |NATIVE_PLUGIN_USES_PANNING

  1333.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1335.     /* audioIns  */ 2,

  1336.     /* audioOuts */ 2,

  1337.     /* midiIns   */ 0,

  1338.     /* midiOuts  */ 0,

  1339.     /* paramIns  */ 12-2,

  1340.     /* paramOuts */ 0,

  1341.     /* name      */ "ZynChorus",

  1342.     /* label     */ "zynchorus",

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

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

  1345.     PluginDescriptorFILL(FxChorusPlugin)

  1346. };

  1347. 

  1348. static const NativePluginDescriptor fxDistortionDesc = {

  1349.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1351.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1353.     /* audioIns  */ 2,

  1354.     /* audioOuts */ 2,

  1355.     /* midiIns   */ 0,

  1356.     /* midiOuts  */ 0,

  1357.     /* paramIns  */ 11-2,

  1358.     /* paramOuts */ 0,

  1359.     /* name      */ "ZynDistortion",

  1360.     /* label     */ "zyndistortion",

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

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

  1363.     PluginDescriptorFILL(FxDistortionPlugin)

  1364. };

  1365. 

  1366. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1367.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1369.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1371.     /* audioIns  */ 2,

  1372.     /* audioOuts */ 2,

  1373.     /* midiIns   */ 0,

  1374.     /* midiOuts  */ 0,

  1375.     /* paramIns  */ 10-2,

  1376.     /* paramOuts */ 0,

  1377.     /* name      */ "ZynDynamicFilter",

  1378.     /* label     */ "zyndynamicfilter",

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

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

  1381.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1382. };

  1383. 

  1384. static const NativePluginDescriptor fxEchoDesc = {

  1385.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1387.                                                   |NATIVE_PLUGIN_USES_PANNING

  1388.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1390.     /* audioIns  */ 2,

  1391.     /* audioOuts */ 2,

  1392.     /* midiIns   */ 0,

  1393.     /* midiOuts  */ 0,

  1394.     /* paramIns  */ 7-2,

  1395.     /* paramOuts */ 0,

  1396.     /* name      */ "ZynEcho",

  1397.     /* label     */ "zynecho",

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

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

  1400.     PluginDescriptorFILL(FxEchoPlugin)

  1401. };

  1402. 

  1403. static const NativePluginDescriptor fxPhaserDesc = {

  1404.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1406.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1408.     /* audioIns  */ 2,

  1409.     /* audioOuts */ 2,

  1410.     /* midiIns   */ 0,

  1411.     /* midiOuts  */ 0,

  1412.     /* paramIns  */ 15-2,

  1413.     /* paramOuts */ 0,

  1414.     /* name      */ "ZynPhaser",

  1415.     /* label     */ "zynphaser",

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

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

  1418.     PluginDescriptorFILL(FxPhaserPlugin)

  1419. };

  1420. 

  1421. static const NativePluginDescriptor fxReverbDesc = {

  1422.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1424.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

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

  1426.     /* audioIns  */ 2,

  1427.     /* audioOuts */ 2,

  1428.     /* midiIns   */ 0,

  1429.     /* midiOuts  */ 0,

  1430.     /* paramIns  */ 13-2,

  1431.     /* paramOuts */ 0,

  1432.     /* name      */ "ZynReverb",

  1433.     /* label     */ "zynreverb",

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

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

  1436.     PluginDescriptorFILL(FxReverbPlugin)

  1437. };

  1438. 

  1439. // -----------------------------------------------------------------------

  1440. 

  1441. CARLA_EXPORT

  1442. void carla_register_native_plugin_zynaddsubfx_fx();

  1443. 

  1444. CARLA_EXPORT

  1445. void carla_register_native_plugin_zynaddsubfx_fx()

  1446. {

  1447.     carla_register_native_plugin(&fxAlienWahDesc);

  1448.     carla_register_native_plugin(&fxChorusDesc);

  1449.     carla_register_native_plugin(&fxDistortionDesc);

  1450.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1451.     carla_register_native_plugin(&fxEchoDesc);

  1452.     carla_register_native_plugin(&fxPhaserDesc);

  1453.     carla_register_native_plugin(&fxReverbDesc);

  1454. }

  1455. 

  1456. // -----------------------------------------------------------------------