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

1491 lines
44KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2017 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 "AppConfig.h"

  31. #include "juce_audio_basics/juce_audio_basics.h"

  32. 

  33. using juce::roundToIntAccurate;

  34. using juce::FloatVectorOperations;

  35. using juce::SharedResourcePointer;

  36. 

  37. // -----------------------------------------------------------------------

  38. 

  39. template<class ZynFX>

  40. class FxAbstractPlugin : public NativePluginClass

  41. {

  42. protected:

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

  44.         : NativePluginClass(host),

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

  46.           fProgramCount(programCount),

  47.           fParamValues(new uchar[paramCount]),

  48.           fParamsChanged(new bool[paramCount]),

  49.           fNextProgram(-1),

  50.           fBufferSize(getBufferSize()),

  51.           fSampleRate(getSampleRate()),

  52.           fFilterParams(nullptr),

  53.           fEffect(nullptr),

  54.           efxoutl(nullptr),

  55.           efxoutr(nullptr)

  56.     {

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

  58. 

  59.         efxoutl = new float[fBufferSize];

  60.         efxoutr = new float[fBufferSize];

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

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

  63. 

  64.         std::memset(fParamsChanged, 0, sizeof(bool)*fParamCount);

  65. 

  66.         doReinit(true);

  67.     }

  68. 

  69.     ~FxAbstractPlugin() override

  70.     {

  71.         if (efxoutl != nullptr)

  72.         {

  73.             delete[] efxoutl;

  74.             efxoutl = nullptr;

  75.         }

  76. 

  77.         if (efxoutr != nullptr)

  78.         {

  79.             delete[] efxoutr;

  80.             efxoutr = nullptr;

  81.         }

  82. 

  83.         if (fEffect != nullptr)

  84.         {

  85.             delete fEffect;

  86.             fEffect = nullptr;

  87.         }

  88.     }

  89. 

  90.     // -------------------------------------------------------------------

  91.     // Plugin parameter calls

  92. 

  93.     uint32_t getParameterCount() const final

  94.     {

  95.         return fParamCount;

  96.     }

  97. 

  98.     float getParameterValue(const uint32_t index) const final

  99.     {

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

  101.     }

  102. 

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

  104.     // Plugin midi-program calls

  105. 

  106.     uint32_t getMidiProgramCount() const final

  107.     {

  108.         return fProgramCount;

  109.     }

  110. 

  111.     // -------------------------------------------------------------------

  112.     // Plugin state calls

  113. 

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

  115.     {

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

  117. 

  118.         fParamValues[index] = static_cast<uchar>(ivalue);

  119.         fParamsChanged[index] = true;

  120.     }

  121. 

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

  123.     {

  124.         fNextProgram = program;

  125.     }

  126. 

  127.     // -------------------------------------------------------------------

  128.     // Plugin process calls

  129. 

  130.     void activate() final

  131.     {

  132.         fEffect->cleanup();

  133.     }

  134. 

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

  136.     {

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

  138. 

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

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

  141.         else

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

  143. 

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

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

  146.         else

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

  148. 

  149.         const int32_t nextProgram = fNextProgram;

  150.         fNextProgram = -1;

  151. 

  152.         if (nextProgram >= 0)

  153.         {

  154.             fEffect->setpreset(static_cast<uchar>(nextProgram));

  155. 

  156.             // reset volume and pan

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

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

  159. 

  160.             // ignore next

  161.             std::memset(fParamsChanged, 0, sizeof(bool)*fParamCount);

  162.         }

  163.         else

  164.         {

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

  166.             {

  167.                 if (! fParamsChanged[i])

  168.                     continue;

  169. 

  170.                 fEffect->changepar(i+2, fParamValues[i]);

  171.                 fParamsChanged[i] = false;

  172.             }

  173.         }

  174. 

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

  176. 

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

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

  179.     }

  180. 

  181.     // -------------------------------------------------------------------

  182.     // Plugin dispatcher

  183. 

  184.     void bufferSizeChanged(const uint32_t bufferSize) final

  185.     {

  186.         if (fBufferSize == bufferSize)

  187.             return;

  188. 

  189.         fBufferSize = bufferSize;

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

  191. 

  192.         delete[] efxoutl;

  193.         delete[] efxoutr;

  194.         efxoutl = new float[bufferSize];

  195.         efxoutr = new float[bufferSize];

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

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

  198. 

  199.         doReinit(false);

  200.     }

  201. 

  202.     void sampleRateChanged(const double sampleRate) final

  203.     {

  204.         if (fSampleRate == sampleRate)

  205.             return;

  206. 

  207.         fSampleRate = sampleRate;

  208. 

  209.         doReinit(false);

  210.     }

  211. 

  212.     void doReinit(const bool firstInit)

  213.     {

  214.         uchar params[fParamCount];

  215. 

  216.         if (fEffect != nullptr)

  217.         {

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

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

  220. 

  221.             delete fEffect;

  222.         }

  223. 

  224.         EffectParams pars(fAllocator.getObject(), false, efxoutl, efxoutr, 0,

  225.                           static_cast<uint>(fSampleRate), static_cast<int>(fBufferSize), &fFilterParams);

  226. 

  227.         fEffect = new ZynFX(pars);

  228. 

  229.         if (firstInit)

  230.         {

  231.             fEffect->setpreset(0);

  232. 

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

  234.                 fParamValues[i] = fEffect->getpar(i+2);

  235.         }

  236.         else

  237.         {

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

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

  240.         }

  241. 

  242.         // reset volume and pan

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

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

  245.     }

  246. 

  247.     // -------------------------------------------------------------------

  248. 

  249.     const uint32_t fParamCount;

  250.     const uint32_t fProgramCount;

  251. 

  252.     uchar* const fParamValues;

  253.     bool*  const fParamsChanged;

  254.     int32_t      fNextProgram;

  255. 

  256.     uint32_t fBufferSize;

  257.     double   fSampleRate;

  258. 

  259.     FilterParams fFilterParams;

  260.     Effect* fEffect;

  261.     float*  efxoutl;

  262.     float*  efxoutr;

  263. 

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

  265.     SharedResourcePointer<AllocatorClass> fAllocator;

  266. 

  267.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  268. };

  269. 

  270. // -----------------------------------------------------------------------

  271. 

  272. class FxAlienWahPlugin : public FxAbstractPlugin<Alienwah>

  273. {

  274. public:

  275.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

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

  277. 

  278. protected:

  279.     // -------------------------------------------------------------------

  280.     // Plugin parameter calls

  281. 

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

  283.     {

  284.         if (index >= fParamCount)

  285.             return nullptr;

  286. 

  287.         static NativeParameter param;

  288.         static NativeParameterScalePoint scalePoints[2];

  289. 

  290.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  291. 

  292.         param.name = nullptr;

  293.         param.unit = nullptr;

  294.         param.ranges.def       = 1.0f;

  295.         param.ranges.min       = 0.0f;

  296.         param.ranges.max       = 127.0f;

  297.         param.ranges.step      = 1.0f;

  298.         param.ranges.stepSmall = 1.0f;

  299.         param.ranges.stepLarge = 20.0f;

  300.         param.scalePointCount  = 0;

  301.         param.scalePoints      = nullptr;

  302. 

  303.         switch (index)

  304.         {

  305.         case 0:

  306.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  307.             param.name = "LFO Frequency";

  308.             param.ranges.def = 70.0f;

  309.             break;

  310.         case 1:

  311.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  312.             param.name = "LFO Randomness";

  313.             param.ranges.def = 0.0f;

  314.             break;

  315.         case 2:

  316.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  317.             param.name = "LFO Type";

  318.             param.ranges.def = 0.0f;

  319.             param.ranges.max = 1.0f;

  320.             param.scalePointCount = 2;

  321.             param.scalePoints     = scalePoints;

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

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

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

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

  326.             break;

  327.         case 3:

  328.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  329.             param.name = "LFO Stereo";

  330.             param.ranges.def = 62.0f;

  331.             break;

  332.         case 4:

  333.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  334.             param.name = "Depth";

  335.             param.ranges.def = 60.0f;

  336.             break;

  337.         case 5:

  338.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  339.             param.name = "Feedback";

  340.             param.ranges.def = 105.0f;

  341.             break;

  342.         case 6:

  343.             param.name = "Delay";

  344.             param.ranges.def = 25.0f;

  345.             param.ranges.min = 1.0f;

  346.             param.ranges.max = 100.0f;

  347.             break;

  348.         case 7:

  349.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  351.             param.ranges.def = 0.0f;

  352.             break;

  353.         case 8:

  354.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  355.             param.name = "Phase";

  356.             param.ranges.def = 64.0f;

  357.             break;

  358.         }

  359. 

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

  361. 

  362.         return &param;

  363.     }

  364. 

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

  366.     // Plugin midi-program calls

  367. 

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

  369.     {

  370.         if (index >= fProgramCount)

  371.             return nullptr;

  372. 

  373.         static NativeMidiProgram midiProg;

  374. 

  375.         midiProg.bank    = 0;

  376.         midiProg.program = index;

  377. 

  378.         switch (index)

  379.         {

  380.         case 0:

  381.             midiProg.name = "AlienWah1";

  382.             break;

  383.         case 1:

  384.             midiProg.name = "AlienWah2";

  385.             break;

  386.         case 2:

  387.             midiProg.name = "AlienWah3";

  388.             break;

  389.         case 3:

  390.             midiProg.name = "AlienWah4";

  391.             break;

  392.         default:

  393.             midiProg.name = nullptr;

  394.             break;

  395.         }

  396. 

  397.         return &midiProg;

  398.     }

  399. 

  400.     // -------------------------------------------------------------------

  401. 

  402.     PluginClassEND(FxAlienWahPlugin)

  403.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  404. };

  405. 

  406. // -----------------------------------------------------------------------

  407. 

  408. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  409. {

  410. public:

  411.     FxChorusPlugin(const NativeHostDescriptor* const host)

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

  413. 

  414. protected:

  415.     // -------------------------------------------------------------------

  416.     // Plugin parameter calls

  417. 

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

  419.     {

  420.         if (index >= fParamCount)

  421.             return nullptr;

  422. 

  423.         static NativeParameter param;

  424.         static NativeParameterScalePoint scalePoints[2];

  425. 

  426.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  427. 

  428.         param.name = nullptr;

  429.         param.unit = nullptr;

  430.         param.ranges.def       = 1.0f;

  431.         param.ranges.min       = 0.0f;

  432.         param.ranges.max       = 127.0f;

  433.         param.ranges.step      = 1.0f;

  434.         param.ranges.stepSmall = 1.0f;

  435.         param.ranges.stepLarge = 20.0f;

  436.         param.scalePointCount  = 0;

  437.         param.scalePoints      = nullptr;

  438. 

  439.         switch (index)

  440.         {

  441.         case 0:

  442.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  443.             param.name = "LFO Frequency";

  444.             param.ranges.def = 50.0f;

  445.             break;

  446.         case 1:

  447.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  448.             param.name = "LFO Randomness";

  449.             param.ranges.def = 0.0f;

  450.             break;

  451.         case 2:

  452.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  453.             param.name = "LFO Type";

  454.             param.ranges.def = 0.0f;

  455.             param.ranges.max = 1.0f;

  456.             param.scalePointCount = 2;

  457.             param.scalePoints     = scalePoints;

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

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

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

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

  462.             break;

  463.         case 3:

  464.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  465.             param.name = "LFO Stereo";

  466.             param.ranges.def = 90.0f;

  467.             break;

  468.         case 4:

  469.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  470.             param.name = "Depth";

  471.             param.ranges.def = 40.0f;

  472.             break;

  473.         case 5:

  474.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  475.             param.name = "Delay";

  476.             param.ranges.def = 85.0f;

  477.             break;

  478.         case 6:

  479.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  480.             param.name = "Feedback";

  481.             param.ranges.def = 64.0f;

  482.             break;

  483.         case 7:

  484.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  486.             param.ranges.def = 119.0f;

  487.             break;

  488.         case 8:

  489.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  490.             param.name = "Flange Mode";

  491.             param.ranges.def = 0.0f;

  492.             param.ranges.max = 1.0f;

  493.             break;

  494.         case 9:

  495.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  496.             param.name = "Subtract Output";

  497.             param.ranges.def = 0.0f;

  498.             param.ranges.max = 1.0f;

  499.             break;

  500.         }

  501. 

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

  503. 

  504.         return &param;

  505.     }

  506. 

  507.     // -------------------------------------------------------------------

  508.     // Plugin midi-program calls

  509. 

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

  511.     {

  512.         if (index >= fProgramCount)

  513.             return nullptr;

  514. 

  515.         static NativeMidiProgram midiProg;

  516. 

  517.         midiProg.bank    = 0;

  518.         midiProg.program = index;

  519. 

  520.         switch (index)

  521.         {

  522.         case 0:

  523.             midiProg.name = "Chorus1";

  524.             break;

  525.         case 1:

  526.             midiProg.name = "Chorus2";

  527.             break;

  528.         case 2:

  529.             midiProg.name = "Chorus3";

  530.             break;

  531.         case 3:

  532.             midiProg.name = "Celeste1";

  533.             break;

  534.         case 4:

  535.             midiProg.name = "Celeste2";

  536.             break;

  537.         case 5:

  538.             midiProg.name = "Flange1";

  539.             break;

  540.         case 6:

  541.             midiProg.name = "Flange2";

  542.             break;

  543.         case 7:

  544.             midiProg.name = "Flange3";

  545.             break;

  546.         case 8:

  547.             midiProg.name = "Flange4";

  548.             break;

  549.         case 9:

  550.             midiProg.name = "Flange5";

  551.             break;

  552.         default:

  553.             midiProg.name = nullptr;

  554.             break;

  555.         }

  556. 

  557.         return &midiProg;

  558.     }

  559. 

  560.     // -------------------------------------------------------------------

  561. 

  562.     PluginClassEND(FxChorusPlugin)

  563.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  564. };

  565. 

  566. // -----------------------------------------------------------------------

  567. 

  568. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  569. {

  570. public:

  571.     FxDistortionPlugin(const NativeHostDescriptor* const host)

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

  573. 

  574. protected:

  575.     // -------------------------------------------------------------------

  576.     // Plugin parameter calls

  577. 

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

  579.     {

  580.         if (index >= fParamCount)

  581.             return nullptr;

  582. 

  583.         static NativeParameter param;

  584.         static NativeParameterScalePoint scalePoints[14];

  585. 

  586.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  587. 

  588.         param.name = nullptr;

  589.         param.unit = nullptr;

  590.         param.ranges.def       = 1.0f;

  591.         param.ranges.min       = 0.0f;

  592.         param.ranges.max       = 127.0f;

  593.         param.ranges.step      = 1.0f;

  594.         param.ranges.stepSmall = 1.0f;

  595.         param.ranges.stepLarge = 20.0f;

  596.         param.scalePointCount  = 0;

  597.         param.scalePoints      = nullptr;

  598. 

  599.         switch (index)

  600.         {

  601.         case 0:

  602.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  604.             param.ranges.def = 35.0f;

  605.             break;

  606.         case 1:

  607.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  608.             param.name = "Drive";

  609.             param.ranges.def = 56.0f;

  610.             break;

  611.         case 2:

  612.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  613.             param.name = "Level";

  614.             param.ranges.def = 70.0f;

  615.             break;

  616.         case 3:

  617.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  618.             param.name = "Type";

  619.             param.ranges.def = 0.0f;

  620.             param.ranges.max = 13.0f;

  621.             param.scalePointCount = 14;

  622.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  651.             break;

  652.         case 4:

  653.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  654.             param.name = "Negate";

  655.             param.ranges.def = 0.0f;

  656.             param.ranges.max = 1.0f;

  657.             break;

  658.         case 5:

  659.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  661.             param.ranges.def = 96.0f;

  662.             break;

  663.         case 6:

  664.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  666.             param.ranges.def = 0.0f;

  667.             break;

  668.         case 7:

  669.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  670.             param.name = "Stereo";

  671.             param.ranges.def = 0.0f;

  672.             param.ranges.max = 1.0f;

  673.             break;

  674.         case 8:

  675.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  677.             param.ranges.def = 0.0f;

  678.             param.ranges.max = 1.0f;

  679.             break;

  680.         }

  681. 

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

  683. 

  684.         return &param;

  685.     }

  686. 

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

  688.     // Plugin midi-program calls

  689. 

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

  691.     {

  692.         if (index >= fProgramCount)

  693.             return nullptr;

  694. 

  695.         static NativeMidiProgram midiProg;

  696. 

  697.         midiProg.bank    = 0;

  698.         midiProg.program = index;

  699. 

  700.         switch (index)

  701.         {

  702.         case 0:

  703.             midiProg.name = "Overdrive 1";

  704.             break;

  705.         case 1:

  706.             midiProg.name = "Overdrive 2";

  707.             break;

  708.         case 2:

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

  710.             break;

  711.         case 3:

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

  713.             break;

  714.         case 4:

  715.             midiProg.name = "Guitar Amp";

  716.             break;

  717.         case 5:

  718.             midiProg.name = "Quantisize";

  719.             break;

  720.         default:

  721.             midiProg.name = nullptr;

  722.             break;

  723.         }

  724. 

  725.         return &midiProg;

  726.     }

  727. 

  728.     // -------------------------------------------------------------------

  729. 

  730.     PluginClassEND(FxDistortionPlugin)

  731.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  732. };

  733. 

  734. // -----------------------------------------------------------------------

  735. 

  736. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  737. {

  738. public:

  739.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

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

  741. 

  742. protected:

  743.     // -------------------------------------------------------------------

  744.     // Plugin parameter calls

  745. 

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

  747.     {

  748.         if (index >= fParamCount)

  749.             return nullptr;

  750. 

  751.         static NativeParameter param;

  752.         static NativeParameterScalePoint scalePoints[2];

  753. 

  754.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  755. 

  756.         param.name = nullptr;

  757.         param.unit = nullptr;

  758.         param.ranges.def       = 1.0f;

  759.         param.ranges.min       = 0.0f;

  760.         param.ranges.max       = 127.0f;

  761.         param.ranges.step      = 1.0f;

  762.         param.ranges.stepSmall = 1.0f;

  763.         param.ranges.stepLarge = 20.0f;

  764.         param.scalePointCount  = 0;

  765.         param.scalePoints      = nullptr;

  766. 

  767.         switch (index)

  768.         {

  769.         case 0:

  770.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  771.             param.name = "LFO Frequency";

  772.             param.ranges.def = 80.0f;

  773.             break;

  774.         case 1:

  775.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  776.             param.name = "LFO Randomness";

  777.             param.ranges.def = 0.0f;

  778.             break;

  779.         case 2:

  780.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  781.             param.name = "LFO Type";

  782.             param.ranges.def = 0.0f;

  783.             param.ranges.max = 1.0f;

  784.             param.scalePointCount = 2;

  785.             param.scalePoints     = scalePoints;

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

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

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

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

  790.             break;

  791.         case 3:

  792.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  793.             param.name = "LFO Stereo";

  794.             param.ranges.def = 64.0f;

  795.             break;

  796.         case 4:

  797.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  798.             param.name = "LFO Depth";

  799.             param.ranges.def = 0.0f;

  800.             break;

  801.         case 5:

  802.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  803.             param.name = "Amp sns";

  804.             param.ranges.def = 90.0f;

  805.             break;

  806.         case 6:

  807.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  809.             param.ranges.def = 0.0f;

  810.             param.ranges.max = 1.0f;

  811.             break;

  812.         case 7:

  813.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  814.             param.name = "Amp Smooth";

  815.             param.ranges.def = 60.0f;

  816.             break;

  817.         }

  818. 

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

  820. 

  821.         return &param;

  822.     }

  823. 

  824.     // -------------------------------------------------------------------

  825.     // Plugin midi-program calls

  826. 

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

  828.     {

  829.         if (index >= fProgramCount)

  830.             return nullptr;

  831. 

  832.         static NativeMidiProgram midiProg;

  833. 

  834.         midiProg.bank    = 0;

  835.         midiProg.program = index;

  836. 

  837.         switch (index)

  838.         {

  839.         case 0:

  840.             midiProg.name = "WahWah";

  841.             break;

  842.         case 1:

  843.             midiProg.name = "AutoWah";

  844.             break;

  845.         case 2:

  846.             midiProg.name = "Sweep";

  847.             break;

  848.         case 3:

  849.             midiProg.name = "VocalMorph1";

  850.             break;

  851.         case 4:

  852.             midiProg.name = "VocalMorph2";

  853.             break;

  854.         default:

  855.             midiProg.name = nullptr;

  856.             break;

  857.         }

  858. 

  859.         return &midiProg;

  860.     }

  861. 

  862.     // -------------------------------------------------------------------

  863. 

  864.     PluginClassEND(FxDynamicFilterPlugin)

  865.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  866. };

  867. 

  868. // -----------------------------------------------------------------------

  869. 

  870. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  871. {

  872. public:

  873.     FxEchoPlugin(const NativeHostDescriptor* const host)

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

  875. 

  876. protected:

  877.     // -------------------------------------------------------------------

  878.     // Plugin parameter calls

  879. 

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

  881.     {

  882.         if (index >= fParamCount)

  883.             return nullptr;

  884. 

  885.         static NativeParameter param;

  886. 

  887.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  888. 

  889.         param.name = nullptr;

  890.         param.unit = nullptr;

  891.         param.ranges.def       = 1.0f;

  892.         param.ranges.min       = 0.0f;

  893.         param.ranges.max       = 127.0f;

  894.         param.ranges.step      = 1.0f;

  895.         param.ranges.stepSmall = 1.0f;

  896.         param.ranges.stepLarge = 20.0f;

  897.         param.scalePointCount  = 0;

  898.         param.scalePoints      = nullptr;

  899. 

  900.         switch (index)

  901.         {

  902.         case 0:

  903.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  904.             param.name = "Delay";

  905.             param.ranges.def = 35.0f;

  906.             break;

  907.         case 1:

  908.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  910.             param.ranges.def = 64.0f;

  911.             break;

  912.         case 2:

  913.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  915.             param.ranges.def = 30.0f;

  916.             break;

  917.         case 3:

  918.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  919.             param.name = "Feedback";

  920.             param.ranges.def = 59.0f;

  921.             break;

  922.         case 4:

  923.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  924.             param.name = "High Damp";

  925.             param.ranges.def = 0.0f;

  926.             break;

  927.         }

  928. 

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

  930. 

  931.         return &param;

  932.     }

  933. 

  934.     // -------------------------------------------------------------------

  935.     // Plugin midi-program calls

  936. 

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

  938.     {

  939.         if (index >= fProgramCount)

  940.             return nullptr;

  941. 

  942.         static NativeMidiProgram midiProg;

  943. 

  944.         midiProg.bank    = 0;

  945.         midiProg.program = index;

  946. 

  947.         switch (index)

  948.         {

  949.         case 0:

  950.             midiProg.name = "Echo 1";

  951.             break;

  952.         case 1:

  953.             midiProg.name = "Echo 2";

  954.             break;

  955.         case 2:

  956.             midiProg.name = "Echo 3";

  957.             break;

  958.         case 3:

  959.             midiProg.name = "Simple Echo";

  960.             break;

  961.         case 4:

  962.             midiProg.name = "Canyon";

  963.             break;

  964.         case 5:

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

  966.             break;

  967.         case 6:

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

  969.             break;

  970.         case 7:

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

  972.             break;

  973.         case 8:

  974.             midiProg.name = "Feedback Echo";

  975.             break;

  976.         default:

  977.             midiProg.name = nullptr;

  978.             break;

  979.         }

  980. 

  981.         return &midiProg;

  982.     }

  983. 

  984.     // -------------------------------------------------------------------

  985. 

  986.     PluginClassEND(FxEchoPlugin)

  987.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  988. };

  989. 

  990. // -----------------------------------------------------------------------

  991. 

  992. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  993. {

  994. public:

  995.     FxPhaserPlugin(const NativeHostDescriptor* const host)

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

  997. 

  998. protected:

  999.     // -------------------------------------------------------------------

  1000.     // Plugin parameter calls

  1001. 

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

  1003.     {

  1004.         if (index >= fParamCount)

  1005.             return nullptr;

  1006. 

  1007.         static NativeParameter param;

  1008.         static NativeParameterScalePoint scalePoints[2];

  1009. 

  1010.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1011. 

  1012.         param.name = nullptr;

  1013.         param.unit = nullptr;

  1014.         param.ranges.def       = 1.0f;

  1015.         param.ranges.min       = 0.0f;

  1016.         param.ranges.max       = 127.0f;

  1017.         param.ranges.step      = 1.0f;

  1018.         param.ranges.stepSmall = 1.0f;

  1019.         param.ranges.stepLarge = 20.0f;

  1020.         param.scalePointCount  = 0;

  1021.         param.scalePoints      = nullptr;

  1022. 

  1023.         switch (index)

  1024.         {

  1025.         case 0:

  1026.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1027.             param.name = "LFO Frequency";

  1028.             param.ranges.def = 36.0f;

  1029.             break;

  1030.         case 1:

  1031.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1032.             param.name = "LFO Randomness";

  1033.             param.ranges.def = 0.0f;

  1034.             break;

  1035.         case 2:

  1036.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1037.             param.name = "LFO Type";

  1038.             param.ranges.def = 0.0f;

  1039.             param.ranges.max = 1.0f;

  1040.             param.scalePointCount = 2;

  1041.             param.scalePoints     = scalePoints;

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

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

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

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

  1046.             break;

  1047.         case 3:

  1048.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1049.             param.name = "LFO Stereo";

  1050.             param.ranges.def = 64.0f;

  1051.             break;

  1052.         case 4:

  1053.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1054.             param.name = "Depth";

  1055.             param.ranges.def = 110.0f;

  1056.             break;

  1057.         case 5:

  1058.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1059.             param.name = "Feedback";

  1060.             param.ranges.def = 64.0f;

  1061.             break;

  1062.         case 6:

  1063.             param.name = "Stages";

  1064.             param.ranges.def = 1.0f;

  1065.             param.ranges.min = 1.0f;

  1066.             param.ranges.max = 12.0f;

  1067.             break;

  1068.         case 7:

  1069.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1071.             param.ranges.def = 0.0f;

  1072.             break;

  1073.         case 8:

  1074.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1075.             param.name = "Subtract Output";

  1076.             param.ranges.def = 0.0f;

  1077.             param.ranges.max = 1.0f;

  1078.             break;

  1079.         case 9:

  1080.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1082.             param.ranges.def = 20.0f;

  1083.             break;

  1084.         case 10:

  1085.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1086.             param.name = "Hyper";

  1087.             param.ranges.def = 0.0f;

  1088.             param.ranges.max = 1.0f;

  1089.             break;

  1090.         case 11:

  1091.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1092.             param.name = "Distortion";

  1093.             param.ranges.def = 0.0f;

  1094.             break;

  1095.         case 12:

  1096.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1097.             param.name = "Analog";

  1098.             param.ranges.def = 0.0f;

  1099.             param.ranges.max = 1.0f;

  1100.             break;

  1101.         }

  1102. 

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

  1104. 

  1105.         return &param;

  1106.     }

  1107. 

  1108.     // -------------------------------------------------------------------

  1109.     // Plugin midi-program calls

  1110. 

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

  1112.     {

  1113.         if (index >= fProgramCount)

  1114.             return nullptr;

  1115. 

  1116.         static NativeMidiProgram midiProg;

  1117. 

  1118.         midiProg.bank    = 0;

  1119.         midiProg.program = index;

  1120. 

  1121.         switch (index)

  1122.         {

  1123.         case 0:

  1124.             midiProg.name = "Phaser 1";

  1125.             break;

  1126.         case 1:

  1127.             midiProg.name = "Phaser 2";

  1128.             break;

  1129.         case 2:

  1130.             midiProg.name = "Phaser 3";

  1131.             break;

  1132.         case 3:

  1133.             midiProg.name = "Phaser 4";

  1134.             break;

  1135.         case 4:

  1136.             midiProg.name = "Phaser 5";

  1137.             break;

  1138.         case 5:

  1139.             midiProg.name = "Phaser 6";

  1140.             break;

  1141.         case 6:

  1142.             midiProg.name = "APhaser 1";

  1143.             break;

  1144.         case 7:

  1145.             midiProg.name = "APhaser 2";

  1146.             break;

  1147.         case 8:

  1148.             midiProg.name = "APhaser 3";

  1149.             break;

  1150.         case 9:

  1151.             midiProg.name = "APhaser 4";

  1152.             break;

  1153.         case 10:

  1154.             midiProg.name = "APhaser 5";

  1155.             break;

  1156.         case 11:

  1157.             midiProg.name = "APhaser 6";

  1158.             break;

  1159.         default:

  1160.             midiProg.name = nullptr;

  1161.             break;

  1162.         }

  1163. 

  1164.         return &midiProg;

  1165.     }

  1166. 

  1167.     // -------------------------------------------------------------------

  1168. 

  1169.     PluginClassEND(FxPhaserPlugin)

  1170.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1171. };

  1172. 

  1173. // -----------------------------------------------------------------------

  1174. 

  1175. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1176. {

  1177. public:

  1178.     FxReverbPlugin(const NativeHostDescriptor* const host)

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

  1180. 

  1181. protected:

  1182.     // -------------------------------------------------------------------

  1183.     // Plugin parameter calls

  1184. 

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

  1186.     {

  1187.         if (index >= fParamCount)

  1188.             return nullptr;

  1189. 

  1190.         static NativeParameter param;

  1191.         static NativeParameterScalePoint scalePoints[3];

  1192. 

  1193.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1194. 

  1195.         param.name = nullptr;

  1196.         param.unit = nullptr;

  1197.         param.ranges.def       = 1.0f;

  1198.         param.ranges.min       = 0.0f;

  1199.         param.ranges.max       = 127.0f;

  1200.         param.ranges.step      = 1.0f;

  1201.         param.ranges.stepSmall = 1.0f;

  1202.         param.ranges.stepLarge = 20.0f;

  1203.         param.scalePointCount  = 0;

  1204.         param.scalePoints      = nullptr;

  1205. 

  1206.         switch (index)

  1207.         {

  1208.         case 0:

  1209.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1210.             param.name = "Time";

  1211.             param.ranges.def = 63.0f;

  1212.             break;

  1213.         case 1:

  1214.             param.name = "Delay";

  1215.             param.ranges.def = 24.0f;

  1216.             break;

  1217.         case 2:

  1218.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1219.             param.name = "Feedback";

  1220.             param.ranges.def = 0.0f;

  1221.             break;

  1222.         case 3:

  1223.             hints = 0x0;

  1224.             param.name = "bw";

  1225.             break;

  1226.         case 4:

  1227.             hints = 0x0;

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

  1229.             break;

  1230.         case 5:

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

  1232.             param.ranges.def = 85.0f;

  1233.             break;

  1234.         case 6:

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

  1236.             param.ranges.def = 5.0f;

  1237.             break;

  1238.         case 7:

  1239.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1240.             param.name = "Damp";

  1241.             param.ranges.def = 83.0f;

  1242.             param.ranges.min = 64.0f;

  1243.             break;

  1244.         case 8:

  1245.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1246.             param.name = "Type";

  1247.             param.ranges.def = 1.0f;

  1248.             param.ranges.max = 2.0f;

  1249.             param.scalePointCount = 3;

  1250.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1257.             break;

  1258.         case 9:

  1259.             param.name = "Room size";

  1260.             param.ranges.def = 64.0f;

  1261.             param.ranges.min = 1.0f;

  1262.             break;

  1263.         case 10:

  1264.             param.name = "Bandwidth";

  1265.             param.ranges.def = 20.0f;

  1266.             break;

  1267.         }

  1268. 

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

  1270. 

  1271.         return &param;

  1272.     }

  1273. 

  1274.     // -------------------------------------------------------------------

  1275.     // Plugin midi-program calls

  1276. 

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

  1278.     {

  1279.         if (index >= fProgramCount)

  1280.             return nullptr;

  1281. 

  1282.         static NativeMidiProgram midiProg;

  1283. 

  1284.         midiProg.bank    = 0;

  1285.         midiProg.program = index;

  1286. 

  1287.         switch (index)

  1288.         {

  1289.         case 0:

  1290.             midiProg.name = "Cathedral1";

  1291.             break;

  1292.         case 1:

  1293.             midiProg.name = "Cathedral2";

  1294.             break;

  1295.         case 2:

  1296.             midiProg.name = "Cathedral3";

  1297.             break;

  1298.         case 3:

  1299.             midiProg.name = "Hall1";

  1300.             break;

  1301.         case 4:

  1302.             midiProg.name = "Hall2";

  1303.             break;

  1304.         case 5:

  1305.             midiProg.name = "Room1";

  1306.             break;

  1307.         case 6:

  1308.             midiProg.name = "Room2";

  1309.             break;

  1310.         case 7:

  1311.             midiProg.name = "Basement";

  1312.             break;

  1313.         case 8:

  1314.             midiProg.name = "Tunnel";

  1315.             break;

  1316.         case 9:

  1317.             midiProg.name = "Echoed1";

  1318.             break;

  1319.         case 10:

  1320.             midiProg.name = "Echoed2";

  1321.             break;

  1322.         case 11:

  1323.             midiProg.name = "VeryLong1";

  1324.             break;

  1325.         case 12:

  1326.             midiProg.name = "VeryLong2";

  1327.             break;

  1328.         default:

  1329.             midiProg.name = nullptr;

  1330.             break;

  1331.         }

  1332. 

  1333.         return &midiProg;

  1334.     }

  1335. 

  1336.     // -------------------------------------------------------------------

  1337. 

  1338.     PluginClassEND(FxReverbPlugin)

  1339.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1340. };

  1341. 

  1342. // -----------------------------------------------------------------------

  1343. 

  1344. static const NativePluginDescriptor fxAlienWahDesc = {

  1345.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1347.                                                   |NATIVE_PLUGIN_USES_PANNING

  1348.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1349.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1350.     /* audioIns  */ 2,

  1351.     /* audioOuts */ 2,

  1352.     /* midiIns   */ 0,

  1353.     /* midiOuts  */ 0,

  1354.     /* paramIns  */ 11-2,

  1355.     /* paramOuts */ 0,

  1356.     /* name      */ "ZynAlienWah",

  1357.     /* label     */ "zynalienwah",

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

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

  1360.     PluginDescriptorFILL(FxAlienWahPlugin)

  1361. };

  1362. 

  1363. static const NativePluginDescriptor fxChorusDesc = {

  1364.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1366.                                                   |NATIVE_PLUGIN_USES_PANNING

  1367.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1368.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1369.     /* audioIns  */ 2,

  1370.     /* audioOuts */ 2,

  1371.     /* midiIns   */ 0,

  1372.     /* midiOuts  */ 0,

  1373.     /* paramIns  */ 12-2,

  1374.     /* paramOuts */ 0,

  1375.     /* name      */ "ZynChorus",

  1376.     /* label     */ "zynchorus",

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

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

  1379.     PluginDescriptorFILL(FxChorusPlugin)

  1380. };

  1381. 

  1382. static const NativePluginDescriptor fxDistortionDesc = {

  1383.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1385.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1386.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1387.     /* audioIns  */ 2,

  1388.     /* audioOuts */ 2,

  1389.     /* midiIns   */ 0,

  1390.     /* midiOuts  */ 0,

  1391.     /* paramIns  */ 11-2,

  1392.     /* paramOuts */ 0,

  1393.     /* name      */ "ZynDistortion",

  1394.     /* label     */ "zyndistortion",

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

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

  1397.     PluginDescriptorFILL(FxDistortionPlugin)

  1398. };

  1399. 

  1400. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1401.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1403.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1404.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1405.     /* audioIns  */ 2,

  1406.     /* audioOuts */ 2,

  1407.     /* midiIns   */ 0,

  1408.     /* midiOuts  */ 0,

  1409.     /* paramIns  */ 10-2,

  1410.     /* paramOuts */ 0,

  1411.     /* name      */ "ZynDynamicFilter",

  1412.     /* label     */ "zyndynamicfilter",

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

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

  1415.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1416. };

  1417. 

  1418. static const NativePluginDescriptor fxEchoDesc = {

  1419.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1421.                                                   |NATIVE_PLUGIN_USES_PANNING

  1422.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1423.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1424.     /* audioIns  */ 2,

  1425.     /* audioOuts */ 2,

  1426.     /* midiIns   */ 0,

  1427.     /* midiOuts  */ 0,

  1428.     /* paramIns  */ 7-2,

  1429.     /* paramOuts */ 0,

  1430.     /* name      */ "ZynEcho",

  1431.     /* label     */ "zynecho",

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

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

  1434.     PluginDescriptorFILL(FxEchoPlugin)

  1435. };

  1436. 

  1437. static const NativePluginDescriptor fxPhaserDesc = {

  1438.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1440.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1441.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1442.     /* audioIns  */ 2,

  1443.     /* audioOuts */ 2,

  1444.     /* midiIns   */ 0,

  1445.     /* midiOuts  */ 0,

  1446.     /* paramIns  */ 15-2,

  1447.     /* paramOuts */ 0,

  1448.     /* name      */ "ZynPhaser",

  1449.     /* label     */ "zynphaser",

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

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

  1452.     PluginDescriptorFILL(FxPhaserPlugin)

  1453. };

  1454. 

  1455. static const NativePluginDescriptor fxReverbDesc = {

  1456.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1458.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1459.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1460.     /* audioIns  */ 2,

  1461.     /* audioOuts */ 2,

  1462.     /* midiIns   */ 0,

  1463.     /* midiOuts  */ 0,

  1464.     /* paramIns  */ 13-2,

  1465.     /* paramOuts */ 0,

  1466.     /* name      */ "ZynReverb",

  1467.     /* label     */ "zynreverb",

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

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

  1470.     PluginDescriptorFILL(FxReverbPlugin)

  1471. };

  1472. 

  1473. // -----------------------------------------------------------------------

  1474. 

  1475. CARLA_EXPORT

  1476. void carla_register_native_plugin_zynaddsubfx_fx();

  1477. 

  1478. CARLA_EXPORT

  1479. void carla_register_native_plugin_zynaddsubfx_fx()

  1480. {

  1481.     carla_register_native_plugin(&fxAlienWahDesc);

  1482.     carla_register_native_plugin(&fxChorusDesc);

  1483.     carla_register_native_plugin(&fxDistortionDesc);

  1484.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1485.     carla_register_native_plugin(&fxEchoDesc);

  1486.     carla_register_native_plugin(&fxPhaserDesc);

  1487.     carla_register_native_plugin(&fxReverbDesc);

  1488. }

  1489. 

  1490. // -----------------------------------------------------------------------