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

1493 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. using namespace zyncarla;

  38. 

  39. // -----------------------------------------------------------------------

  40. 

  41. template<class ZynFX>

  42. class FxAbstractPlugin : public NativePluginClass

  43. {

  44. protected:

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

  46.         : NativePluginClass(host),

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

  48.           fProgramCount(programCount),

  49.           fParamValues(new uchar[paramCount]),

  50.           fParamsChanged(new bool[paramCount]),

  51.           fNextProgram(-1),

  52.           fBufferSize(getBufferSize()),

  53.           fSampleRate(getSampleRate()),

  54.           fFilterParams(nullptr),

  55.           fEffect(nullptr),

  56.           efxoutl(nullptr),

  57.           efxoutr(nullptr)

  58.     {

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

  60. 

  61.         efxoutl = new float[fBufferSize];

  62.         efxoutr = new float[fBufferSize];

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

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

  65. 

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

  67. 

  68.         doReinit(true);

  69.     }

  70. 

  71.     ~FxAbstractPlugin() override

  72.     {

  73.         if (efxoutl != nullptr)

  74.         {

  75.             delete[] efxoutl;

  76.             efxoutl = nullptr;

  77.         }

  78. 

  79.         if (efxoutr != nullptr)

  80.         {

  81.             delete[] efxoutr;

  82.             efxoutr = nullptr;

  83.         }

  84. 

  85.         if (fEffect != nullptr)

  86.         {

  87.             delete fEffect;

  88.             fEffect = nullptr;

  89.         }

  90.     }

  91. 

  92.     // -------------------------------------------------------------------

  93.     // Plugin parameter calls

  94. 

  95.     uint32_t getParameterCount() const final

  96.     {

  97.         return fParamCount;

  98.     }

  99. 

  100.     float getParameterValue(const uint32_t index) const final

  101.     {

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

  103.     }

  104. 

  105.     // -------------------------------------------------------------------

  106.     // Plugin midi-program calls

  107. 

  108.     uint32_t getMidiProgramCount() const final

  109.     {

  110.         return fProgramCount;

  111.     }

  112. 

  113.     // -------------------------------------------------------------------

  114.     // Plugin state calls

  115. 

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

  117.     {

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

  119. 

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

  121.         fParamsChanged[index] = true;

  122.     }

  123. 

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

  125.     {

  126.         fNextProgram = program;

  127.     }

  128. 

  129.     // -------------------------------------------------------------------

  130.     // Plugin process calls

  131. 

  132.     void activate() final

  133.     {

  134.         fEffect->cleanup();

  135.     }

  136. 

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

  138.     {

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

  140. 

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

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

  143.         else

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

  145. 

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

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

  148.         else

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

  150. 

  151.         const int32_t nextProgram = fNextProgram;

  152.         fNextProgram = -1;

  153. 

  154.         if (nextProgram >= 0)

  155.         {

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

  157. 

  158.             // reset volume and pan

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

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

  161. 

  162.             // ignore next

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

  164.         }

  165.         else

  166.         {

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

  168.             {

  169.                 if (! fParamsChanged[i])

  170.                     continue;

  171. 

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

  173.                 fParamsChanged[i] = false;

  174.             }

  175.         }

  176. 

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

  178. 

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

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

  181.     }

  182. 

  183.     // -------------------------------------------------------------------

  184.     // Plugin dispatcher

  185. 

  186.     void bufferSizeChanged(const uint32_t bufferSize) final

  187.     {

  188.         if (fBufferSize == bufferSize)

  189.             return;

  190. 

  191.         fBufferSize = bufferSize;

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

  193. 

  194.         delete[] efxoutl;

  195.         delete[] efxoutr;

  196.         efxoutl = new float[bufferSize];

  197.         efxoutr = new float[bufferSize];

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

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

  200. 

  201.         doReinit(false);

  202.     }

  203. 

  204.     void sampleRateChanged(const double sampleRate) final

  205.     {

  206.         if (fSampleRate == sampleRate)

  207.             return;

  208. 

  209.         fSampleRate = sampleRate;

  210. 

  211.         doReinit(false);

  212.     }

  213. 

  214.     void doReinit(const bool firstInit)

  215.     {

  216.         uchar params[fParamCount];

  217. 

  218.         if (fEffect != nullptr)

  219.         {

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

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

  222. 

  223.             delete fEffect;

  224.         }

  225. 

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

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

  228. 

  229.         fEffect = new ZynFX(pars);

  230. 

  231.         if (firstInit)

  232.         {

  233.             fEffect->setpreset(0);

  234. 

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

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

  237.         }

  238.         else

  239.         {

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

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

  242.         }

  243. 

  244.         // reset volume and pan

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

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

  247.     }

  248. 

  249.     // -------------------------------------------------------------------

  250. 

  251.     const uint32_t fParamCount;

  252.     const uint32_t fProgramCount;

  253. 

  254.     uchar* const fParamValues;

  255.     bool*  const fParamsChanged;

  256.     int32_t      fNextProgram;

  257. 

  258.     uint32_t fBufferSize;

  259.     double   fSampleRate;

  260. 

  261.     FilterParams fFilterParams;

  262.     Effect* fEffect;

  263.     float*  efxoutl;

  264.     float*  efxoutr;

  265. 

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

  267.     SharedResourcePointer<AllocatorClass> fAllocator;

  268. 

  269.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  270. };

  271. 

  272. // -----------------------------------------------------------------------

  273. 

  274. class FxAlienWahPlugin : public FxAbstractPlugin<Alienwah>

  275. {

  276. public:

  277.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

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

  279. 

  280. protected:

  281.     // -------------------------------------------------------------------

  282.     // Plugin parameter calls

  283. 

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

  285.     {

  286.         if (index >= fParamCount)

  287.             return nullptr;

  288. 

  289.         static NativeParameter param;

  290.         static NativeParameterScalePoint scalePoints[2];

  291. 

  292.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  293. 

  294.         param.name = nullptr;

  295.         param.unit = nullptr;

  296.         param.ranges.def       = 1.0f;

  297.         param.ranges.min       = 0.0f;

  298.         param.ranges.max       = 127.0f;

  299.         param.ranges.step      = 1.0f;

  300.         param.ranges.stepSmall = 1.0f;

  301.         param.ranges.stepLarge = 20.0f;

  302.         param.scalePointCount  = 0;

  303.         param.scalePoints      = nullptr;

  304. 

  305.         switch (index)

  306.         {

  307.         case 0:

  308.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  309.             param.name = "LFO Frequency";

  310.             param.ranges.def = 70.0f;

  311.             break;

  312.         case 1:

  313.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  314.             param.name = "LFO Randomness";

  315.             param.ranges.def = 0.0f;

  316.             break;

  317.         case 2:

  318.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  319.             param.name = "LFO Type";

  320.             param.ranges.def = 0.0f;

  321.             param.ranges.max = 1.0f;

  322.             param.scalePointCount = 2;

  323.             param.scalePoints     = scalePoints;

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

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

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

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

  328.             break;

  329.         case 3:

  330.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  331.             param.name = "LFO Stereo";

  332.             param.ranges.def = 62.0f;

  333.             break;

  334.         case 4:

  335.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  336.             param.name = "Depth";

  337.             param.ranges.def = 60.0f;

  338.             break;

  339.         case 5:

  340.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  341.             param.name = "Feedback";

  342.             param.ranges.def = 105.0f;

  343.             break;

  344.         case 6:

  345.             param.name = "Delay";

  346.             param.ranges.def = 25.0f;

  347.             param.ranges.min = 1.0f;

  348.             param.ranges.max = 100.0f;

  349.             break;

  350.         case 7:

  351.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  353.             param.ranges.def = 0.0f;

  354.             break;

  355.         case 8:

  356.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  357.             param.name = "Phase";

  358.             param.ranges.def = 64.0f;

  359.             break;

  360.         }

  361. 

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

  363. 

  364.         return &param;

  365.     }

  366. 

  367.     // -------------------------------------------------------------------

  368.     // Plugin midi-program calls

  369. 

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

  371.     {

  372.         if (index >= fProgramCount)

  373.             return nullptr;

  374. 

  375.         static NativeMidiProgram midiProg;

  376. 

  377.         midiProg.bank    = 0;

  378.         midiProg.program = index;

  379. 

  380.         switch (index)

  381.         {

  382.         case 0:

  383.             midiProg.name = "AlienWah1";

  384.             break;

  385.         case 1:

  386.             midiProg.name = "AlienWah2";

  387.             break;

  388.         case 2:

  389.             midiProg.name = "AlienWah3";

  390.             break;

  391.         case 3:

  392.             midiProg.name = "AlienWah4";

  393.             break;

  394.         default:

  395.             midiProg.name = nullptr;

  396.             break;

  397.         }

  398. 

  399.         return &midiProg;

  400.     }

  401. 

  402.     // -------------------------------------------------------------------

  403. 

  404.     PluginClassEND(FxAlienWahPlugin)

  405.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  406. };

  407. 

  408. // -----------------------------------------------------------------------

  409. 

  410. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  411. {

  412. public:

  413.     FxChorusPlugin(const NativeHostDescriptor* const host)

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

  415. 

  416. protected:

  417.     // -------------------------------------------------------------------

  418.     // Plugin parameter calls

  419. 

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

  421.     {

  422.         if (index >= fParamCount)

  423.             return nullptr;

  424. 

  425.         static NativeParameter param;

  426.         static NativeParameterScalePoint scalePoints[2];

  427. 

  428.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  429. 

  430.         param.name = nullptr;

  431.         param.unit = nullptr;

  432.         param.ranges.def       = 1.0f;

  433.         param.ranges.min       = 0.0f;

  434.         param.ranges.max       = 127.0f;

  435.         param.ranges.step      = 1.0f;

  436.         param.ranges.stepSmall = 1.0f;

  437.         param.ranges.stepLarge = 20.0f;

  438.         param.scalePointCount  = 0;

  439.         param.scalePoints      = nullptr;

  440. 

  441.         switch (index)

  442.         {

  443.         case 0:

  444.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  445.             param.name = "LFO Frequency";

  446.             param.ranges.def = 50.0f;

  447.             break;

  448.         case 1:

  449.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  450.             param.name = "LFO Randomness";

  451.             param.ranges.def = 0.0f;

  452.             break;

  453.         case 2:

  454.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  455.             param.name = "LFO Type";

  456.             param.ranges.def = 0.0f;

  457.             param.ranges.max = 1.0f;

  458.             param.scalePointCount = 2;

  459.             param.scalePoints     = scalePoints;

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

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

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

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

  464.             break;

  465.         case 3:

  466.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  467.             param.name = "LFO Stereo";

  468.             param.ranges.def = 90.0f;

  469.             break;

  470.         case 4:

  471.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  472.             param.name = "Depth";

  473.             param.ranges.def = 40.0f;

  474.             break;

  475.         case 5:

  476.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  477.             param.name = "Delay";

  478.             param.ranges.def = 85.0f;

  479.             break;

  480.         case 6:

  481.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  482.             param.name = "Feedback";

  483.             param.ranges.def = 64.0f;

  484.             break;

  485.         case 7:

  486.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  488.             param.ranges.def = 119.0f;

  489.             break;

  490.         case 8:

  491.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  492.             param.name = "Flange Mode";

  493.             param.ranges.def = 0.0f;

  494.             param.ranges.max = 1.0f;

  495.             break;

  496.         case 9:

  497.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  498.             param.name = "Subtract Output";

  499.             param.ranges.def = 0.0f;

  500.             param.ranges.max = 1.0f;

  501.             break;

  502.         }

  503. 

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

  505. 

  506.         return &param;

  507.     }

  508. 

  509.     // -------------------------------------------------------------------

  510.     // Plugin midi-program calls

  511. 

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

  513.     {

  514.         if (index >= fProgramCount)

  515.             return nullptr;

  516. 

  517.         static NativeMidiProgram midiProg;

  518. 

  519.         midiProg.bank    = 0;

  520.         midiProg.program = index;

  521. 

  522.         switch (index)

  523.         {

  524.         case 0:

  525.             midiProg.name = "Chorus1";

  526.             break;

  527.         case 1:

  528.             midiProg.name = "Chorus2";

  529.             break;

  530.         case 2:

  531.             midiProg.name = "Chorus3";

  532.             break;

  533.         case 3:

  534.             midiProg.name = "Celeste1";

  535.             break;

  536.         case 4:

  537.             midiProg.name = "Celeste2";

  538.             break;

  539.         case 5:

  540.             midiProg.name = "Flange1";

  541.             break;

  542.         case 6:

  543.             midiProg.name = "Flange2";

  544.             break;

  545.         case 7:

  546.             midiProg.name = "Flange3";

  547.             break;

  548.         case 8:

  549.             midiProg.name = "Flange4";

  550.             break;

  551.         case 9:

  552.             midiProg.name = "Flange5";

  553.             break;

  554.         default:

  555.             midiProg.name = nullptr;

  556.             break;

  557.         }

  558. 

  559.         return &midiProg;

  560.     }

  561. 

  562.     // -------------------------------------------------------------------

  563. 

  564.     PluginClassEND(FxChorusPlugin)

  565.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  566. };

  567. 

  568. // -----------------------------------------------------------------------

  569. 

  570. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  571. {

  572. public:

  573.     FxDistortionPlugin(const NativeHostDescriptor* const host)

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

  575. 

  576. protected:

  577.     // -------------------------------------------------------------------

  578.     // Plugin parameter calls

  579. 

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

  581.     {

  582.         if (index >= fParamCount)

  583.             return nullptr;

  584. 

  585.         static NativeParameter param;

  586.         static NativeParameterScalePoint scalePoints[14];

  587. 

  588.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  589. 

  590.         param.name = nullptr;

  591.         param.unit = nullptr;

  592.         param.ranges.def       = 1.0f;

  593.         param.ranges.min       = 0.0f;

  594.         param.ranges.max       = 127.0f;

  595.         param.ranges.step      = 1.0f;

  596.         param.ranges.stepSmall = 1.0f;

  597.         param.ranges.stepLarge = 20.0f;

  598.         param.scalePointCount  = 0;

  599.         param.scalePoints      = nullptr;

  600. 

  601.         switch (index)

  602.         {

  603.         case 0:

  604.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  606.             param.ranges.def = 35.0f;

  607.             break;

  608.         case 1:

  609.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  610.             param.name = "Drive";

  611.             param.ranges.def = 56.0f;

  612.             break;

  613.         case 2:

  614.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  615.             param.name = "Level";

  616.             param.ranges.def = 70.0f;

  617.             break;

  618.         case 3:

  619.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  620.             param.name = "Type";

  621.             param.ranges.def = 0.0f;

  622.             param.ranges.max = 13.0f;

  623.             param.scalePointCount = 14;

  624.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  653.             break;

  654.         case 4:

  655.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  656.             param.name = "Negate";

  657.             param.ranges.def = 0.0f;

  658.             param.ranges.max = 1.0f;

  659.             break;

  660.         case 5:

  661.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  663.             param.ranges.def = 96.0f;

  664.             break;

  665.         case 6:

  666.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  668.             param.ranges.def = 0.0f;

  669.             break;

  670.         case 7:

  671.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  672.             param.name = "Stereo";

  673.             param.ranges.def = 0.0f;

  674.             param.ranges.max = 1.0f;

  675.             break;

  676.         case 8:

  677.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  679.             param.ranges.def = 0.0f;

  680.             param.ranges.max = 1.0f;

  681.             break;

  682.         }

  683. 

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

  685. 

  686.         return &param;

  687.     }

  688. 

  689.     // -------------------------------------------------------------------

  690.     // Plugin midi-program calls

  691. 

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

  693.     {

  694.         if (index >= fProgramCount)

  695.             return nullptr;

  696. 

  697.         static NativeMidiProgram midiProg;

  698. 

  699.         midiProg.bank    = 0;

  700.         midiProg.program = index;

  701. 

  702.         switch (index)

  703.         {

  704.         case 0:

  705.             midiProg.name = "Overdrive 1";

  706.             break;

  707.         case 1:

  708.             midiProg.name = "Overdrive 2";

  709.             break;

  710.         case 2:

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

  712.             break;

  713.         case 3:

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

  715.             break;

  716.         case 4:

  717.             midiProg.name = "Guitar Amp";

  718.             break;

  719.         case 5:

  720.             midiProg.name = "Quantisize";

  721.             break;

  722.         default:

  723.             midiProg.name = nullptr;

  724.             break;

  725.         }

  726. 

  727.         return &midiProg;

  728.     }

  729. 

  730.     // -------------------------------------------------------------------

  731. 

  732.     PluginClassEND(FxDistortionPlugin)

  733.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  734. };

  735. 

  736. // -----------------------------------------------------------------------

  737. 

  738. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  739. {

  740. public:

  741.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

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

  743. 

  744. protected:

  745.     // -------------------------------------------------------------------

  746.     // Plugin parameter calls

  747. 

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

  749.     {

  750.         if (index >= fParamCount)

  751.             return nullptr;

  752. 

  753.         static NativeParameter param;

  754.         static NativeParameterScalePoint scalePoints[2];

  755. 

  756.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  757. 

  758.         param.name = nullptr;

  759.         param.unit = nullptr;

  760.         param.ranges.def       = 1.0f;

  761.         param.ranges.min       = 0.0f;

  762.         param.ranges.max       = 127.0f;

  763.         param.ranges.step      = 1.0f;

  764.         param.ranges.stepSmall = 1.0f;

  765.         param.ranges.stepLarge = 20.0f;

  766.         param.scalePointCount  = 0;

  767.         param.scalePoints      = nullptr;

  768. 

  769.         switch (index)

  770.         {

  771.         case 0:

  772.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  773.             param.name = "LFO Frequency";

  774.             param.ranges.def = 80.0f;

  775.             break;

  776.         case 1:

  777.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  778.             param.name = "LFO Randomness";

  779.             param.ranges.def = 0.0f;

  780.             break;

  781.         case 2:

  782.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  783.             param.name = "LFO Type";

  784.             param.ranges.def = 0.0f;

  785.             param.ranges.max = 1.0f;

  786.             param.scalePointCount = 2;

  787.             param.scalePoints     = scalePoints;

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

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

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

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

  792.             break;

  793.         case 3:

  794.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  795.             param.name = "LFO Stereo";

  796.             param.ranges.def = 64.0f;

  797.             break;

  798.         case 4:

  799.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  800.             param.name = "LFO Depth";

  801.             param.ranges.def = 0.0f;

  802.             break;

  803.         case 5:

  804.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  805.             param.name = "Amp sns";

  806.             param.ranges.def = 90.0f;

  807.             break;

  808.         case 6:

  809.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  811.             param.ranges.def = 0.0f;

  812.             param.ranges.max = 1.0f;

  813.             break;

  814.         case 7:

  815.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  816.             param.name = "Amp Smooth";

  817.             param.ranges.def = 60.0f;

  818.             break;

  819.         }

  820. 

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

  822. 

  823.         return &param;

  824.     }

  825. 

  826.     // -------------------------------------------------------------------

  827.     // Plugin midi-program calls

  828. 

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

  830.     {

  831.         if (index >= fProgramCount)

  832.             return nullptr;

  833. 

  834.         static NativeMidiProgram midiProg;

  835. 

  836.         midiProg.bank    = 0;

  837.         midiProg.program = index;

  838. 

  839.         switch (index)

  840.         {

  841.         case 0:

  842.             midiProg.name = "WahWah";

  843.             break;

  844.         case 1:

  845.             midiProg.name = "AutoWah";

  846.             break;

  847.         case 2:

  848.             midiProg.name = "Sweep";

  849.             break;

  850.         case 3:

  851.             midiProg.name = "VocalMorph1";

  852.             break;

  853.         case 4:

  854.             midiProg.name = "VocalMorph2";

  855.             break;

  856.         default:

  857.             midiProg.name = nullptr;

  858.             break;

  859.         }

  860. 

  861.         return &midiProg;

  862.     }

  863. 

  864.     // -------------------------------------------------------------------

  865. 

  866.     PluginClassEND(FxDynamicFilterPlugin)

  867.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  868. };

  869. 

  870. // -----------------------------------------------------------------------

  871. 

  872. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  873. {

  874. public:

  875.     FxEchoPlugin(const NativeHostDescriptor* const host)

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

  877. 

  878. protected:

  879.     // -------------------------------------------------------------------

  880.     // Plugin parameter calls

  881. 

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

  883.     {

  884.         if (index >= fParamCount)

  885.             return nullptr;

  886. 

  887.         static NativeParameter param;

  888. 

  889.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  890. 

  891.         param.name = nullptr;

  892.         param.unit = nullptr;

  893.         param.ranges.def       = 1.0f;

  894.         param.ranges.min       = 0.0f;

  895.         param.ranges.max       = 127.0f;

  896.         param.ranges.step      = 1.0f;

  897.         param.ranges.stepSmall = 1.0f;

  898.         param.ranges.stepLarge = 20.0f;

  899.         param.scalePointCount  = 0;

  900.         param.scalePoints      = nullptr;

  901. 

  902.         switch (index)

  903.         {

  904.         case 0:

  905.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  906.             param.name = "Delay";

  907.             param.ranges.def = 35.0f;

  908.             break;

  909.         case 1:

  910.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  912.             param.ranges.def = 64.0f;

  913.             break;

  914.         case 2:

  915.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  917.             param.ranges.def = 30.0f;

  918.             break;

  919.         case 3:

  920.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  921.             param.name = "Feedback";

  922.             param.ranges.def = 59.0f;

  923.             break;

  924.         case 4:

  925.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  926.             param.name = "High Damp";

  927.             param.ranges.def = 0.0f;

  928.             break;

  929.         }

  930. 

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

  932. 

  933.         return &param;

  934.     }

  935. 

  936.     // -------------------------------------------------------------------

  937.     // Plugin midi-program calls

  938. 

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

  940.     {

  941.         if (index >= fProgramCount)

  942.             return nullptr;

  943. 

  944.         static NativeMidiProgram midiProg;

  945. 

  946.         midiProg.bank    = 0;

  947.         midiProg.program = index;

  948. 

  949.         switch (index)

  950.         {

  951.         case 0:

  952.             midiProg.name = "Echo 1";

  953.             break;

  954.         case 1:

  955.             midiProg.name = "Echo 2";

  956.             break;

  957.         case 2:

  958.             midiProg.name = "Echo 3";

  959.             break;

  960.         case 3:

  961.             midiProg.name = "Simple Echo";

  962.             break;

  963.         case 4:

  964.             midiProg.name = "Canyon";

  965.             break;

  966.         case 5:

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

  968.             break;

  969.         case 6:

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

  971.             break;

  972.         case 7:

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

  974.             break;

  975.         case 8:

  976.             midiProg.name = "Feedback Echo";

  977.             break;

  978.         default:

  979.             midiProg.name = nullptr;

  980.             break;

  981.         }

  982. 

  983.         return &midiProg;

  984.     }

  985. 

  986.     // -------------------------------------------------------------------

  987. 

  988.     PluginClassEND(FxEchoPlugin)

  989.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  990. };

  991. 

  992. // -----------------------------------------------------------------------

  993. 

  994. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  995. {

  996. public:

  997.     FxPhaserPlugin(const NativeHostDescriptor* const host)

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

  999. 

  1000. protected:

  1001.     // -------------------------------------------------------------------

  1002.     // Plugin parameter calls

  1003. 

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

  1005.     {

  1006.         if (index >= fParamCount)

  1007.             return nullptr;

  1008. 

  1009.         static NativeParameter param;

  1010.         static NativeParameterScalePoint scalePoints[2];

  1011. 

  1012.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1013. 

  1014.         param.name = nullptr;

  1015.         param.unit = nullptr;

  1016.         param.ranges.def       = 1.0f;

  1017.         param.ranges.min       = 0.0f;

  1018.         param.ranges.max       = 127.0f;

  1019.         param.ranges.step      = 1.0f;

  1020.         param.ranges.stepSmall = 1.0f;

  1021.         param.ranges.stepLarge = 20.0f;

  1022.         param.scalePointCount  = 0;

  1023.         param.scalePoints      = nullptr;

  1024. 

  1025.         switch (index)

  1026.         {

  1027.         case 0:

  1028.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1029.             param.name = "LFO Frequency";

  1030.             param.ranges.def = 36.0f;

  1031.             break;

  1032.         case 1:

  1033.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1034.             param.name = "LFO Randomness";

  1035.             param.ranges.def = 0.0f;

  1036.             break;

  1037.         case 2:

  1038.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1039.             param.name = "LFO Type";

  1040.             param.ranges.def = 0.0f;

  1041.             param.ranges.max = 1.0f;

  1042.             param.scalePointCount = 2;

  1043.             param.scalePoints     = scalePoints;

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

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

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

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

  1048.             break;

  1049.         case 3:

  1050.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1051.             param.name = "LFO Stereo";

  1052.             param.ranges.def = 64.0f;

  1053.             break;

  1054.         case 4:

  1055.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1056.             param.name = "Depth";

  1057.             param.ranges.def = 110.0f;

  1058.             break;

  1059.         case 5:

  1060.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1061.             param.name = "Feedback";

  1062.             param.ranges.def = 64.0f;

  1063.             break;

  1064.         case 6:

  1065.             param.name = "Stages";

  1066.             param.ranges.def = 1.0f;

  1067.             param.ranges.min = 1.0f;

  1068.             param.ranges.max = 12.0f;

  1069.             break;

  1070.         case 7:

  1071.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1073.             param.ranges.def = 0.0f;

  1074.             break;

  1075.         case 8:

  1076.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1077.             param.name = "Subtract Output";

  1078.             param.ranges.def = 0.0f;

  1079.             param.ranges.max = 1.0f;

  1080.             break;

  1081.         case 9:

  1082.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1084.             param.ranges.def = 20.0f;

  1085.             break;

  1086.         case 10:

  1087.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1088.             param.name = "Hyper";

  1089.             param.ranges.def = 0.0f;

  1090.             param.ranges.max = 1.0f;

  1091.             break;

  1092.         case 11:

  1093.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1094.             param.name = "Distortion";

  1095.             param.ranges.def = 0.0f;

  1096.             break;

  1097.         case 12:

  1098.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1099.             param.name = "Analog";

  1100.             param.ranges.def = 0.0f;

  1101.             param.ranges.max = 1.0f;

  1102.             break;

  1103.         }

  1104. 

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

  1106. 

  1107.         return &param;

  1108.     }

  1109. 

  1110.     // -------------------------------------------------------------------

  1111.     // Plugin midi-program calls

  1112. 

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

  1114.     {

  1115.         if (index >= fProgramCount)

  1116.             return nullptr;

  1117. 

  1118.         static NativeMidiProgram midiProg;

  1119. 

  1120.         midiProg.bank    = 0;

  1121.         midiProg.program = index;

  1122. 

  1123.         switch (index)

  1124.         {

  1125.         case 0:

  1126.             midiProg.name = "Phaser 1";

  1127.             break;

  1128.         case 1:

  1129.             midiProg.name = "Phaser 2";

  1130.             break;

  1131.         case 2:

  1132.             midiProg.name = "Phaser 3";

  1133.             break;

  1134.         case 3:

  1135.             midiProg.name = "Phaser 4";

  1136.             break;

  1137.         case 4:

  1138.             midiProg.name = "Phaser 5";

  1139.             break;

  1140.         case 5:

  1141.             midiProg.name = "Phaser 6";

  1142.             break;

  1143.         case 6:

  1144.             midiProg.name = "APhaser 1";

  1145.             break;

  1146.         case 7:

  1147.             midiProg.name = "APhaser 2";

  1148.             break;

  1149.         case 8:

  1150.             midiProg.name = "APhaser 3";

  1151.             break;

  1152.         case 9:

  1153.             midiProg.name = "APhaser 4";

  1154.             break;

  1155.         case 10:

  1156.             midiProg.name = "APhaser 5";

  1157.             break;

  1158.         case 11:

  1159.             midiProg.name = "APhaser 6";

  1160.             break;

  1161.         default:

  1162.             midiProg.name = nullptr;

  1163.             break;

  1164.         }

  1165. 

  1166.         return &midiProg;

  1167.     }

  1168. 

  1169.     // -------------------------------------------------------------------

  1170. 

  1171.     PluginClassEND(FxPhaserPlugin)

  1172.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1173. };

  1174. 

  1175. // -----------------------------------------------------------------------

  1176. 

  1177. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1178. {

  1179. public:

  1180.     FxReverbPlugin(const NativeHostDescriptor* const host)

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

  1182. 

  1183. protected:

  1184.     // -------------------------------------------------------------------

  1185.     // Plugin parameter calls

  1186. 

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

  1188.     {

  1189.         if (index >= fParamCount)

  1190.             return nullptr;

  1191. 

  1192.         static NativeParameter param;

  1193.         static NativeParameterScalePoint scalePoints[3];

  1194. 

  1195.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1196. 

  1197.         param.name = nullptr;

  1198.         param.unit = nullptr;

  1199.         param.ranges.def       = 1.0f;

  1200.         param.ranges.min       = 0.0f;

  1201.         param.ranges.max       = 127.0f;

  1202.         param.ranges.step      = 1.0f;

  1203.         param.ranges.stepSmall = 1.0f;

  1204.         param.ranges.stepLarge = 20.0f;

  1205.         param.scalePointCount  = 0;

  1206.         param.scalePoints      = nullptr;

  1207. 

  1208.         switch (index)

  1209.         {

  1210.         case 0:

  1211.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1212.             param.name = "Time";

  1213.             param.ranges.def = 63.0f;

  1214.             break;

  1215.         case 1:

  1216.             param.name = "Delay";

  1217.             param.ranges.def = 24.0f;

  1218.             break;

  1219.         case 2:

  1220.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1221.             param.name = "Feedback";

  1222.             param.ranges.def = 0.0f;

  1223.             break;

  1224.         case 3:

  1225.             hints = 0x0;

  1226.             param.name = "bw";

  1227.             break;

  1228.         case 4:

  1229.             hints = 0x0;

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

  1231.             break;

  1232.         case 5:

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

  1234.             param.ranges.def = 85.0f;

  1235.             break;

  1236.         case 6:

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

  1238.             param.ranges.def = 5.0f;

  1239.             break;

  1240.         case 7:

  1241.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1242.             param.name = "Damp";

  1243.             param.ranges.def = 83.0f;

  1244.             param.ranges.min = 64.0f;

  1245.             break;

  1246.         case 8:

  1247.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1248.             param.name = "Type";

  1249.             param.ranges.def = 1.0f;

  1250.             param.ranges.max = 2.0f;

  1251.             param.scalePointCount = 3;

  1252.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1259.             break;

  1260.         case 9:

  1261.             param.name = "Room size";

  1262.             param.ranges.def = 64.0f;

  1263.             param.ranges.min = 1.0f;

  1264.             break;

  1265.         case 10:

  1266.             param.name = "Bandwidth";

  1267.             param.ranges.def = 20.0f;

  1268.             break;

  1269.         }

  1270. 

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

  1272. 

  1273.         return &param;

  1274.     }

  1275. 

  1276.     // -------------------------------------------------------------------

  1277.     // Plugin midi-program calls

  1278. 

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

  1280.     {

  1281.         if (index >= fProgramCount)

  1282.             return nullptr;

  1283. 

  1284.         static NativeMidiProgram midiProg;

  1285. 

  1286.         midiProg.bank    = 0;

  1287.         midiProg.program = index;

  1288. 

  1289.         switch (index)

  1290.         {

  1291.         case 0:

  1292.             midiProg.name = "Cathedral1";

  1293.             break;

  1294.         case 1:

  1295.             midiProg.name = "Cathedral2";

  1296.             break;

  1297.         case 2:

  1298.             midiProg.name = "Cathedral3";

  1299.             break;

  1300.         case 3:

  1301.             midiProg.name = "Hall1";

  1302.             break;

  1303.         case 4:

  1304.             midiProg.name = "Hall2";

  1305.             break;

  1306.         case 5:

  1307.             midiProg.name = "Room1";

  1308.             break;

  1309.         case 6:

  1310.             midiProg.name = "Room2";

  1311.             break;

  1312.         case 7:

  1313.             midiProg.name = "Basement";

  1314.             break;

  1315.         case 8:

  1316.             midiProg.name = "Tunnel";

  1317.             break;

  1318.         case 9:

  1319.             midiProg.name = "Echoed1";

  1320.             break;

  1321.         case 10:

  1322.             midiProg.name = "Echoed2";

  1323.             break;

  1324.         case 11:

  1325.             midiProg.name = "VeryLong1";

  1326.             break;

  1327.         case 12:

  1328.             midiProg.name = "VeryLong2";

  1329.             break;

  1330.         default:

  1331.             midiProg.name = nullptr;

  1332.             break;

  1333.         }

  1334. 

  1335.         return &midiProg;

  1336.     }

  1337. 

  1338.     // -------------------------------------------------------------------

  1339. 

  1340.     PluginClassEND(FxReverbPlugin)

  1341.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1342. };

  1343. 

  1344. // -----------------------------------------------------------------------

  1345. 

  1346. static const NativePluginDescriptor fxAlienWahDesc = {

  1347.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1349.                                                   |NATIVE_PLUGIN_USES_PANNING

  1350.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1351.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1352.     /* audioIns  */ 2,

  1353.     /* audioOuts */ 2,

  1354.     /* midiIns   */ 0,

  1355.     /* midiOuts  */ 0,

  1356.     /* paramIns  */ 11-2,

  1357.     /* paramOuts */ 0,

  1358.     /* name      */ "ZynAlienWah",

  1359.     /* label     */ "zynalienwah",

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

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

  1362.     PluginDescriptorFILL(FxAlienWahPlugin)

  1363. };

  1364. 

  1365. static const NativePluginDescriptor fxChorusDesc = {

  1366.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1368.                                                   |NATIVE_PLUGIN_USES_PANNING

  1369.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1370.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1371.     /* audioIns  */ 2,

  1372.     /* audioOuts */ 2,

  1373.     /* midiIns   */ 0,

  1374.     /* midiOuts  */ 0,

  1375.     /* paramIns  */ 12-2,

  1376.     /* paramOuts */ 0,

  1377.     /* name      */ "ZynChorus",

  1378.     /* label     */ "zynchorus",

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

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

  1381.     PluginDescriptorFILL(FxChorusPlugin)

  1382. };

  1383. 

  1384. static const NativePluginDescriptor fxDistortionDesc = {

  1385.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1387.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1388.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1389.     /* audioIns  */ 2,

  1390.     /* audioOuts */ 2,

  1391.     /* midiIns   */ 0,

  1392.     /* midiOuts  */ 0,

  1393.     /* paramIns  */ 11-2,

  1394.     /* paramOuts */ 0,

  1395.     /* name      */ "ZynDistortion",

  1396.     /* label     */ "zyndistortion",

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

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

  1399.     PluginDescriptorFILL(FxDistortionPlugin)

  1400. };

  1401. 

  1402. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1403.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1405.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1406.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1407.     /* audioIns  */ 2,

  1408.     /* audioOuts */ 2,

  1409.     /* midiIns   */ 0,

  1410.     /* midiOuts  */ 0,

  1411.     /* paramIns  */ 10-2,

  1412.     /* paramOuts */ 0,

  1413.     /* name      */ "ZynDynamicFilter",

  1414.     /* label     */ "zyndynamicfilter",

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

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

  1417.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1418. };

  1419. 

  1420. static const NativePluginDescriptor fxEchoDesc = {

  1421.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1423.                                                   |NATIVE_PLUGIN_USES_PANNING

  1424.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1425.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1426.     /* audioIns  */ 2,

  1427.     /* audioOuts */ 2,

  1428.     /* midiIns   */ 0,

  1429.     /* midiOuts  */ 0,

  1430.     /* paramIns  */ 7-2,

  1431.     /* paramOuts */ 0,

  1432.     /* name      */ "ZynEcho",

  1433.     /* label     */ "zynecho",

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

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

  1436.     PluginDescriptorFILL(FxEchoPlugin)

  1437. };

  1438. 

  1439. static const NativePluginDescriptor fxPhaserDesc = {

  1440.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1442.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1443.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1444.     /* audioIns  */ 2,

  1445.     /* audioOuts */ 2,

  1446.     /* midiIns   */ 0,

  1447.     /* midiOuts  */ 0,

  1448.     /* paramIns  */ 15-2,

  1449.     /* paramOuts */ 0,

  1450.     /* name      */ "ZynPhaser",

  1451.     /* label     */ "zynphaser",

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

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

  1454.     PluginDescriptorFILL(FxPhaserPlugin)

  1455. };

  1456. 

  1457. static const NativePluginDescriptor fxReverbDesc = {

  1458.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1460.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1461.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1462.     /* audioIns  */ 2,

  1463.     /* audioOuts */ 2,

  1464.     /* midiIns   */ 0,

  1465.     /* midiOuts  */ 0,

  1466.     /* paramIns  */ 13-2,

  1467.     /* paramOuts */ 0,

  1468.     /* name      */ "ZynReverb",

  1469.     /* label     */ "zynreverb",

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

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

  1472.     PluginDescriptorFILL(FxReverbPlugin)

  1473. };

  1474. 

  1475. // -----------------------------------------------------------------------

  1476. 

  1477. CARLA_EXPORT

  1478. void carla_register_native_plugin_zynaddsubfx_fx();

  1479. 

  1480. CARLA_EXPORT

  1481. void carla_register_native_plugin_zynaddsubfx_fx()

  1482. {

  1483.     carla_register_native_plugin(&fxAlienWahDesc);

  1484.     carla_register_native_plugin(&fxChorusDesc);

  1485.     carla_register_native_plugin(&fxDistortionDesc);

  1486.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1487.     carla_register_native_plugin(&fxEchoDesc);

  1488.     carla_register_native_plugin(&fxPhaserDesc);

  1489.     carla_register_native_plugin(&fxReverbDesc);

  1490. }

  1491. 

  1492. // -----------------------------------------------------------------------