falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3670 Commits
17 Branches
2.6GB
Tree: 5308d76078
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5308d76078'
${ noResults }
Carla/source/native-plugins/zynaddsubfx-fx.cpp

1504 lines
45KB
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. #if defined(__clang__)

  22. # pragma clang diagnostic push

  23. # pragma clang diagnostic ignored "-Weffc++"

  24. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  25. # pragma GCC diagnostic push

  26. # pragma GCC diagnostic ignored "-Weffc++"

  27. # pragma GCC diagnostic ignored "-Wconversion"

  28. # pragma GCC diagnostic ignored "-Wnon-virtual-dtor"

  29. # pragma GCC diagnostic ignored "-Wsign-conversion"

  30. # pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"

  31. #endif

  32. 

  33. #include "Misc/Allocator.h"

  34. #include "Effects/Alienwah.h"

  35. #include "Effects/Chorus.h"

  36. #include "Effects/Distorsion.h"

  37. #include "Effects/DynamicFilter.h"

  38. #include "Effects/Echo.h"

  39. #include "Effects/Phaser.h"

  40. #include "Effects/Reverb.h"

  41. 

  42. #if defined(__clang__)

  43. # pragma clang diagnostic pop

  44. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  45. # pragma GCC diagnostic pop

  46. #endif

  47. 

  48. #include "AppConfig.h"

  49. #include "juce_core/juce_core.h"

  50. 

  51. using juce::roundToIntAccurate;

  52. 

  53. using namespace zyncarla;

  54. 

  55. // -----------------------------------------------------------------------

  56. 

  57. template<class ZynFX>

  58. class FxAbstractPlugin : public NativePluginClass

  59. {

  60. protected:

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

  62.         : NativePluginClass(host),

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

  64.           fProgramCount(programCount),

  65.           fParamValues(new uchar[paramCount]),

  66.           fParamsChanged(new bool[paramCount]),

  67.           fNextProgram(-1),

  68.           fBufferSize(getBufferSize()),

  69.           fSampleRate(getSampleRate()),

  70.           fFilterParams(nullptr),

  71.           fEffect(nullptr),

  72.           efxoutl(nullptr),

  73.           efxoutr(nullptr),

  74.           fAllocator()

  75.     {

  76.         efxoutl = new float[fBufferSize];

  77.         efxoutr = new float[fBufferSize];

  78.         carla_zeroFloats(efxoutl, fBufferSize);

  79.         carla_zeroFloats(efxoutr, fBufferSize);

  80. 

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

  82. 

  83.         doReinit(true);

  84.     }

  85. 

  86.     ~FxAbstractPlugin() override

  87.     {

  88.         if (efxoutl != nullptr)

  89.         {

  90.             delete[] efxoutl;

  91.             efxoutl = nullptr;

  92.         }

  93. 

  94.         if (efxoutr != nullptr)

  95.         {

  96.             delete[] efxoutr;

  97.             efxoutr = nullptr;

  98.         }

  99. 

  100.         if (fEffect != nullptr)

  101.         {

  102.             delete fEffect;

  103.             fEffect = nullptr;

  104.         }

  105.     }

  106. 

  107.     // -------------------------------------------------------------------

  108.     // Plugin parameter calls

  109. 

  110.     uint32_t getParameterCount() const final

  111.     {

  112.         return fParamCount;

  113.     }

  114. 

  115.     float getParameterValue(const uint32_t index) const final

  116.     {

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

  118.     }

  119. 

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

  121.     // Plugin midi-program calls

  122. 

  123.     uint32_t getMidiProgramCount() const final

  124.     {

  125.         return fProgramCount;

  126.     }

  127. 

  128.     // -------------------------------------------------------------------

  129.     // Plugin state calls

  130. 

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

  132.     {

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

  134. 

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

  136.         fParamsChanged[index] = true;

  137.     }

  138. 

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

  140.     {

  141.         fNextProgram = static_cast<int32_t>(program);

  142.     }

  143. 

  144.     // -------------------------------------------------------------------

  145.     // Plugin process calls

  146. 

  147.     void activate() final

  148.     {

  149.         fEffect->cleanup();

  150.     }

  151. 

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

  153.     {

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

  155.             carla_copyWithMultiply(outBuffer[0], inBuffer[0], 0.5f, frames);

  156.         else

  157.             carla_multiply(outBuffer[0], 0.5f, frames);

  158. 

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

  160.             carla_copyWithMultiply(outBuffer[1], inBuffer[1], 0.5f, frames);

  161.         else

  162.             carla_multiply(outBuffer[1], 0.5f, frames);

  163. 

  164.         const int32_t nextProgram = fNextProgram;

  165.         fNextProgram = -1;

  166. 

  167.         if (nextProgram >= 0)

  168.         {

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

  170. 

  171.             // reset volume and pan

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

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

  174. 

  175.             // ignore next

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

  177.         }

  178.         else

  179.         {

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

  181.             {

  182.                 if (! fParamsChanged[i])

  183.                     continue;

  184. 

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

  186.                 fParamsChanged[i] = false;

  187.             }

  188.         }

  189. 

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

  191. 

  192.         carla_addWithMultiply(outBuffer[0], efxoutl, 0.5f, frames);

  193.         carla_addWithMultiply(outBuffer[1], efxoutr, 0.5f, frames);

  194.     }

  195. 

  196.     // -------------------------------------------------------------------

  197.     // Plugin dispatcher

  198. 

  199.     void bufferSizeChanged(const uint32_t bufferSize) final

  200.     {

  201.         if (fBufferSize == bufferSize)

  202.             return;

  203. 

  204.         fBufferSize = bufferSize;

  205. 

  206.         delete[] efxoutl;

  207.         delete[] efxoutr;

  208.         efxoutl = new float[bufferSize];

  209.         efxoutr = new float[bufferSize];

  210.         carla_zeroFloats(efxoutl, bufferSize);

  211.         carla_zeroFloats(efxoutr, bufferSize);

  212. 

  213.         doReinit(false);

  214.     }

  215. 

  216.     void sampleRateChanged(const double sampleRate) final

  217.     {

  218.         if (carla_isEqual(fSampleRate, sampleRate))

  219.             return;

  220. 

  221.         fSampleRate = sampleRate;

  222. 

  223.         doReinit(false);

  224.     }

  225. 

  226.     void doReinit(const bool firstInit)

  227.     {

  228.         uchar params[fParamCount];

  229. 

  230.         if (fEffect != nullptr)

  231.         {

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

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

  234. 

  235.             delete fEffect;

  236.         }

  237. 

  238.         EffectParams pars(fAllocator, false, efxoutl, efxoutr, 0,

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

  240. 

  241.         fEffect = new ZynFX(pars);

  242. 

  243.         if (firstInit)

  244.         {

  245.             fEffect->setpreset(0);

  246. 

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

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

  249.         }

  250.         else

  251.         {

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

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

  254.         }

  255. 

  256.         // reset volume and pan

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

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

  259.     }

  260. 

  261.     // -------------------------------------------------------------------

  262. 

  263.     const uint32_t fParamCount;

  264.     const uint32_t fProgramCount;

  265. 

  266.     uchar* const fParamValues;

  267.     bool*  const fParamsChanged;

  268.     int32_t      fNextProgram;

  269. 

  270.     uint32_t fBufferSize;

  271.     double   fSampleRate;

  272. 

  273.     FilterParams fFilterParams;

  274.     Effect* fEffect;

  275.     float*  efxoutl;

  276.     float*  efxoutr;

  277. 

  278.     AllocatorClass fAllocator;

  279. 

  280.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  281. };

  282. 

  283. // -----------------------------------------------------------------------

  284. 

  285. class FxAlienWahPlugin : public FxAbstractPlugin<Alienwah>

  286. {

  287. public:

  288.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

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

  290. 

  291. protected:

  292.     // -------------------------------------------------------------------

  293.     // Plugin parameter calls

  294. 

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

  296.     {

  297.         if (index >= fParamCount)

  298.             return nullptr;

  299. 

  300.         static NativeParameter param;

  301.         static NativeParameterScalePoint scalePoints[2];

  302. 

  303.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  304. 

  305.         param.name = nullptr;

  306.         param.unit = nullptr;

  307.         param.ranges.def       = 1.0f;

  308.         param.ranges.min       = 0.0f;

  309.         param.ranges.max       = 127.0f;

  310.         param.ranges.step      = 1.0f;

  311.         param.ranges.stepSmall = 1.0f;

  312.         param.ranges.stepLarge = 20.0f;

  313.         param.scalePointCount  = 0;

  314.         param.scalePoints      = nullptr;

  315. 

  316.         switch (index)

  317.         {

  318.         case 0:

  319.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  320.             param.name = "LFO Frequency";

  321.             param.ranges.def = 70.0f;

  322.             break;

  323.         case 1:

  324.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  325.             param.name = "LFO Randomness";

  326.             param.ranges.def = 0.0f;

  327.             break;

  328.         case 2:

  329.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  330.             param.name = "LFO Type";

  331.             param.ranges.def = 0.0f;

  332.             param.ranges.max = 1.0f;

  333.             param.scalePointCount = 2;

  334.             param.scalePoints     = scalePoints;

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

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

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

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

  339.             break;

  340.         case 3:

  341.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  342.             param.name = "LFO Stereo";

  343.             param.ranges.def = 62.0f;

  344.             break;

  345.         case 4:

  346.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  347.             param.name = "Depth";

  348.             param.ranges.def = 60.0f;

  349.             break;

  350.         case 5:

  351.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  352.             param.name = "Feedback";

  353.             param.ranges.def = 105.0f;

  354.             break;

  355.         case 6:

  356.             param.name = "Delay";

  357.             param.ranges.def = 25.0f;

  358.             param.ranges.min = 1.0f;

  359.             param.ranges.max = 100.0f;

  360.             break;

  361.         case 7:

  362.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  364.             param.ranges.def = 0.0f;

  365.             break;

  366.         case 8:

  367.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  368.             param.name = "Phase";

  369.             param.ranges.def = 64.0f;

  370.             break;

  371.         }

  372. 

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

  374. 

  375.         return &param;

  376.     }

  377. 

  378.     // -------------------------------------------------------------------

  379.     // Plugin midi-program calls

  380. 

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

  382.     {

  383.         if (index >= fProgramCount)

  384.             return nullptr;

  385. 

  386.         static NativeMidiProgram midiProg;

  387. 

  388.         midiProg.bank    = 0;

  389.         midiProg.program = index;

  390. 

  391.         switch (index)

  392.         {

  393.         case 0:

  394.             midiProg.name = "AlienWah1";

  395.             break;

  396.         case 1:

  397.             midiProg.name = "AlienWah2";

  398.             break;

  399.         case 2:

  400.             midiProg.name = "AlienWah3";

  401.             break;

  402.         case 3:

  403.             midiProg.name = "AlienWah4";

  404.             break;

  405.         default:

  406.             midiProg.name = nullptr;

  407.             break;

  408.         }

  409. 

  410.         return &midiProg;

  411.     }

  412. 

  413.     // -------------------------------------------------------------------

  414. 

  415.     PluginClassEND(FxAlienWahPlugin)

  416.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  417. };

  418. 

  419. // -----------------------------------------------------------------------

  420. 

  421. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  422. {

  423. public:

  424.     FxChorusPlugin(const NativeHostDescriptor* const host)

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

  426. 

  427. protected:

  428.     // -------------------------------------------------------------------

  429.     // Plugin parameter calls

  430. 

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

  432.     {

  433.         if (index >= fParamCount)

  434.             return nullptr;

  435. 

  436.         static NativeParameter param;

  437.         static NativeParameterScalePoint scalePoints[2];

  438. 

  439.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  440. 

  441.         param.name = nullptr;

  442.         param.unit = nullptr;

  443.         param.ranges.def       = 1.0f;

  444.         param.ranges.min       = 0.0f;

  445.         param.ranges.max       = 127.0f;

  446.         param.ranges.step      = 1.0f;

  447.         param.ranges.stepSmall = 1.0f;

  448.         param.ranges.stepLarge = 20.0f;

  449.         param.scalePointCount  = 0;

  450.         param.scalePoints      = nullptr;

  451. 

  452.         switch (index)

  453.         {

  454.         case 0:

  455.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  456.             param.name = "LFO Frequency";

  457.             param.ranges.def = 50.0f;

  458.             break;

  459.         case 1:

  460.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  461.             param.name = "LFO Randomness";

  462.             param.ranges.def = 0.0f;

  463.             break;

  464.         case 2:

  465.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  466.             param.name = "LFO Type";

  467.             param.ranges.def = 0.0f;

  468.             param.ranges.max = 1.0f;

  469.             param.scalePointCount = 2;

  470.             param.scalePoints     = scalePoints;

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

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

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

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

  475.             break;

  476.         case 3:

  477.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  478.             param.name = "LFO Stereo";

  479.             param.ranges.def = 90.0f;

  480.             break;

  481.         case 4:

  482.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  483.             param.name = "Depth";

  484.             param.ranges.def = 40.0f;

  485.             break;

  486.         case 5:

  487.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  488.             param.name = "Delay";

  489.             param.ranges.def = 85.0f;

  490.             break;

  491.         case 6:

  492.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  493.             param.name = "Feedback";

  494.             param.ranges.def = 64.0f;

  495.             break;

  496.         case 7:

  497.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  499.             param.ranges.def = 119.0f;

  500.             break;

  501.         case 8:

  502.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  503.             param.name = "Flange Mode";

  504.             param.ranges.def = 0.0f;

  505.             param.ranges.max = 1.0f;

  506.             break;

  507.         case 9:

  508.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  509.             param.name = "Subtract Output";

  510.             param.ranges.def = 0.0f;

  511.             param.ranges.max = 1.0f;

  512.             break;

  513.         }

  514. 

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

  516. 

  517.         return &param;

  518.     }

  519. 

  520.     // -------------------------------------------------------------------

  521.     // Plugin midi-program calls

  522. 

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

  524.     {

  525.         if (index >= fProgramCount)

  526.             return nullptr;

  527. 

  528.         static NativeMidiProgram midiProg;

  529. 

  530.         midiProg.bank    = 0;

  531.         midiProg.program = index;

  532. 

  533.         switch (index)

  534.         {

  535.         case 0:

  536.             midiProg.name = "Chorus1";

  537.             break;

  538.         case 1:

  539.             midiProg.name = "Chorus2";

  540.             break;

  541.         case 2:

  542.             midiProg.name = "Chorus3";

  543.             break;

  544.         case 3:

  545.             midiProg.name = "Celeste1";

  546.             break;

  547.         case 4:

  548.             midiProg.name = "Celeste2";

  549.             break;

  550.         case 5:

  551.             midiProg.name = "Flange1";

  552.             break;

  553.         case 6:

  554.             midiProg.name = "Flange2";

  555.             break;

  556.         case 7:

  557.             midiProg.name = "Flange3";

  558.             break;

  559.         case 8:

  560.             midiProg.name = "Flange4";

  561.             break;

  562.         case 9:

  563.             midiProg.name = "Flange5";

  564.             break;

  565.         default:

  566.             midiProg.name = nullptr;

  567.             break;

  568.         }

  569. 

  570.         return &midiProg;

  571.     }

  572. 

  573.     // -------------------------------------------------------------------

  574. 

  575.     PluginClassEND(FxChorusPlugin)

  576.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  577. };

  578. 

  579. // -----------------------------------------------------------------------

  580. 

  581. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  582. {

  583. public:

  584.     FxDistortionPlugin(const NativeHostDescriptor* const host)

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

  586. 

  587. protected:

  588.     // -------------------------------------------------------------------

  589.     // Plugin parameter calls

  590. 

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

  592.     {

  593.         if (index >= fParamCount)

  594.             return nullptr;

  595. 

  596.         static NativeParameter param;

  597.         static NativeParameterScalePoint scalePoints[14];

  598. 

  599.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  600. 

  601.         param.name = nullptr;

  602.         param.unit = nullptr;

  603.         param.ranges.def       = 1.0f;

  604.         param.ranges.min       = 0.0f;

  605.         param.ranges.max       = 127.0f;

  606.         param.ranges.step      = 1.0f;

  607.         param.ranges.stepSmall = 1.0f;

  608.         param.ranges.stepLarge = 20.0f;

  609.         param.scalePointCount  = 0;

  610.         param.scalePoints      = nullptr;

  611. 

  612.         switch (index)

  613.         {

  614.         case 0:

  615.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  617.             param.ranges.def = 35.0f;

  618.             break;

  619.         case 1:

  620.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  621.             param.name = "Drive";

  622.             param.ranges.def = 56.0f;

  623.             break;

  624.         case 2:

  625.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  626.             param.name = "Level";

  627.             param.ranges.def = 70.0f;

  628.             break;

  629.         case 3:

  630.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  631.             param.name = "Type";

  632.             param.ranges.def = 0.0f;

  633.             param.ranges.max = 13.0f;

  634.             param.scalePointCount = 14;

  635.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  664.             break;

  665.         case 4:

  666.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  667.             param.name = "Negate";

  668.             param.ranges.def = 0.0f;

  669.             param.ranges.max = 1.0f;

  670.             break;

  671.         case 5:

  672.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  674.             param.ranges.def = 96.0f;

  675.             break;

  676.         case 6:

  677.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  679.             param.ranges.def = 0.0f;

  680.             break;

  681.         case 7:

  682.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  683.             param.name = "Stereo";

  684.             param.ranges.def = 0.0f;

  685.             param.ranges.max = 1.0f;

  686.             break;

  687.         case 8:

  688.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  690.             param.ranges.def = 0.0f;

  691.             param.ranges.max = 1.0f;

  692.             break;

  693.         }

  694. 

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

  696. 

  697.         return &param;

  698.     }

  699. 

  700.     // -------------------------------------------------------------------

  701.     // Plugin midi-program calls

  702. 

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

  704.     {

  705.         if (index >= fProgramCount)

  706.             return nullptr;

  707. 

  708.         static NativeMidiProgram midiProg;

  709. 

  710.         midiProg.bank    = 0;

  711.         midiProg.program = index;

  712. 

  713.         switch (index)

  714.         {

  715.         case 0:

  716.             midiProg.name = "Overdrive 1";

  717.             break;

  718.         case 1:

  719.             midiProg.name = "Overdrive 2";

  720.             break;

  721.         case 2:

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

  723.             break;

  724.         case 3:

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

  726.             break;

  727.         case 4:

  728.             midiProg.name = "Guitar Amp";

  729.             break;

  730.         case 5:

  731.             midiProg.name = "Quantisize";

  732.             break;

  733.         default:

  734.             midiProg.name = nullptr;

  735.             break;

  736.         }

  737. 

  738.         return &midiProg;

  739.     }

  740. 

  741.     // -------------------------------------------------------------------

  742. 

  743.     PluginClassEND(FxDistortionPlugin)

  744.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  745. };

  746. 

  747. // -----------------------------------------------------------------------

  748. 

  749. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  750. {

  751. public:

  752.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

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

  754. 

  755. protected:

  756.     // -------------------------------------------------------------------

  757.     // Plugin parameter calls

  758. 

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

  760.     {

  761.         if (index >= fParamCount)

  762.             return nullptr;

  763. 

  764.         static NativeParameter param;

  765.         static NativeParameterScalePoint scalePoints[2];

  766. 

  767.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  768. 

  769.         param.name = nullptr;

  770.         param.unit = nullptr;

  771.         param.ranges.def       = 1.0f;

  772.         param.ranges.min       = 0.0f;

  773.         param.ranges.max       = 127.0f;

  774.         param.ranges.step      = 1.0f;

  775.         param.ranges.stepSmall = 1.0f;

  776.         param.ranges.stepLarge = 20.0f;

  777.         param.scalePointCount  = 0;

  778.         param.scalePoints      = nullptr;

  779. 

  780.         switch (index)

  781.         {

  782.         case 0:

  783.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  784.             param.name = "LFO Frequency";

  785.             param.ranges.def = 80.0f;

  786.             break;

  787.         case 1:

  788.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  789.             param.name = "LFO Randomness";

  790.             param.ranges.def = 0.0f;

  791.             break;

  792.         case 2:

  793.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  794.             param.name = "LFO Type";

  795.             param.ranges.def = 0.0f;

  796.             param.ranges.max = 1.0f;

  797.             param.scalePointCount = 2;

  798.             param.scalePoints     = scalePoints;

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

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

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

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

  803.             break;

  804.         case 3:

  805.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  806.             param.name = "LFO Stereo";

  807.             param.ranges.def = 64.0f;

  808.             break;

  809.         case 4:

  810.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  811.             param.name = "LFO Depth";

  812.             param.ranges.def = 0.0f;

  813.             break;

  814.         case 5:

  815.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  816.             param.name = "Amp sns";

  817.             param.ranges.def = 90.0f;

  818.             break;

  819.         case 6:

  820.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  822.             param.ranges.def = 0.0f;

  823.             param.ranges.max = 1.0f;

  824.             break;

  825.         case 7:

  826.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  827.             param.name = "Amp Smooth";

  828.             param.ranges.def = 60.0f;

  829.             break;

  830.         }

  831. 

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

  833. 

  834.         return &param;

  835.     }

  836. 

  837.     // -------------------------------------------------------------------

  838.     // Plugin midi-program calls

  839. 

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

  841.     {

  842.         if (index >= fProgramCount)

  843.             return nullptr;

  844. 

  845.         static NativeMidiProgram midiProg;

  846. 

  847.         midiProg.bank    = 0;

  848.         midiProg.program = index;

  849. 

  850.         switch (index)

  851.         {

  852.         case 0:

  853.             midiProg.name = "WahWah";

  854.             break;

  855.         case 1:

  856.             midiProg.name = "AutoWah";

  857.             break;

  858.         case 2:

  859.             midiProg.name = "Sweep";

  860.             break;

  861.         case 3:

  862.             midiProg.name = "VocalMorph1";

  863.             break;

  864.         case 4:

  865.             midiProg.name = "VocalMorph2";

  866.             break;

  867.         default:

  868.             midiProg.name = nullptr;

  869.             break;

  870.         }

  871. 

  872.         return &midiProg;

  873.     }

  874. 

  875.     // -------------------------------------------------------------------

  876. 

  877.     PluginClassEND(FxDynamicFilterPlugin)

  878.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  879. };

  880. 

  881. // -----------------------------------------------------------------------

  882. 

  883. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  884. {

  885. public:

  886.     FxEchoPlugin(const NativeHostDescriptor* const host)

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

  888. 

  889. protected:

  890.     // -------------------------------------------------------------------

  891.     // Plugin parameter calls

  892. 

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

  894.     {

  895.         if (index >= fParamCount)

  896.             return nullptr;

  897. 

  898.         static NativeParameter param;

  899. 

  900.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  901. 

  902.         param.name = nullptr;

  903.         param.unit = nullptr;

  904.         param.ranges.def       = 1.0f;

  905.         param.ranges.min       = 0.0f;

  906.         param.ranges.max       = 127.0f;

  907.         param.ranges.step      = 1.0f;

  908.         param.ranges.stepSmall = 1.0f;

  909.         param.ranges.stepLarge = 20.0f;

  910.         param.scalePointCount  = 0;

  911.         param.scalePoints      = nullptr;

  912. 

  913.         switch (index)

  914.         {

  915.         case 0:

  916.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  917.             param.name = "Delay";

  918.             param.ranges.def = 35.0f;

  919.             break;

  920.         case 1:

  921.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  923.             param.ranges.def = 64.0f;

  924.             break;

  925.         case 2:

  926.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  928.             param.ranges.def = 30.0f;

  929.             break;

  930.         case 3:

  931.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  932.             param.name = "Feedback";

  933.             param.ranges.def = 59.0f;

  934.             break;

  935.         case 4:

  936.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  937.             param.name = "High Damp";

  938.             param.ranges.def = 0.0f;

  939.             break;

  940.         }

  941. 

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

  943. 

  944.         return &param;

  945.     }

  946. 

  947.     // -------------------------------------------------------------------

  948.     // Plugin midi-program calls

  949. 

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

  951.     {

  952.         if (index >= fProgramCount)

  953.             return nullptr;

  954. 

  955.         static NativeMidiProgram midiProg;

  956. 

  957.         midiProg.bank    = 0;

  958.         midiProg.program = index;

  959. 

  960.         switch (index)

  961.         {

  962.         case 0:

  963.             midiProg.name = "Echo 1";

  964.             break;

  965.         case 1:

  966.             midiProg.name = "Echo 2";

  967.             break;

  968.         case 2:

  969.             midiProg.name = "Echo 3";

  970.             break;

  971.         case 3:

  972.             midiProg.name = "Simple Echo";

  973.             break;

  974.         case 4:

  975.             midiProg.name = "Canyon";

  976.             break;

  977.         case 5:

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

  979.             break;

  980.         case 6:

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

  982.             break;

  983.         case 7:

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

  985.             break;

  986.         case 8:

  987.             midiProg.name = "Feedback Echo";

  988.             break;

  989.         default:

  990.             midiProg.name = nullptr;

  991.             break;

  992.         }

  993. 

  994.         return &midiProg;

  995.     }

  996. 

  997.     // -------------------------------------------------------------------

  998. 

  999.     PluginClassEND(FxEchoPlugin)

  1000.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  1001. };

  1002. 

  1003. // -----------------------------------------------------------------------

  1004. 

  1005. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  1006. {

  1007. public:

  1008.     FxPhaserPlugin(const NativeHostDescriptor* const host)

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

  1010. 

  1011. protected:

  1012.     // -------------------------------------------------------------------

  1013.     // Plugin parameter calls

  1014. 

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

  1016.     {

  1017.         if (index >= fParamCount)

  1018.             return nullptr;

  1019. 

  1020.         static NativeParameter param;

  1021.         static NativeParameterScalePoint scalePoints[2];

  1022. 

  1023.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1024. 

  1025.         param.name = nullptr;

  1026.         param.unit = nullptr;

  1027.         param.ranges.def       = 1.0f;

  1028.         param.ranges.min       = 0.0f;

  1029.         param.ranges.max       = 127.0f;

  1030.         param.ranges.step      = 1.0f;

  1031.         param.ranges.stepSmall = 1.0f;

  1032.         param.ranges.stepLarge = 20.0f;

  1033.         param.scalePointCount  = 0;

  1034.         param.scalePoints      = nullptr;

  1035. 

  1036.         switch (index)

  1037.         {

  1038.         case 0:

  1039.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1040.             param.name = "LFO Frequency";

  1041.             param.ranges.def = 36.0f;

  1042.             break;

  1043.         case 1:

  1044.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1045.             param.name = "LFO Randomness";

  1046.             param.ranges.def = 0.0f;

  1047.             break;

  1048.         case 2:

  1049.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1050.             param.name = "LFO Type";

  1051.             param.ranges.def = 0.0f;

  1052.             param.ranges.max = 1.0f;

  1053.             param.scalePointCount = 2;

  1054.             param.scalePoints     = scalePoints;

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

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

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

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

  1059.             break;

  1060.         case 3:

  1061.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1062.             param.name = "LFO Stereo";

  1063.             param.ranges.def = 64.0f;

  1064.             break;

  1065.         case 4:

  1066.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1067.             param.name = "Depth";

  1068.             param.ranges.def = 110.0f;

  1069.             break;

  1070.         case 5:

  1071.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1072.             param.name = "Feedback";

  1073.             param.ranges.def = 64.0f;

  1074.             break;

  1075.         case 6:

  1076.             param.name = "Stages";

  1077.             param.ranges.def = 1.0f;

  1078.             param.ranges.min = 1.0f;

  1079.             param.ranges.max = 12.0f;

  1080.             break;

  1081.         case 7:

  1082.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1084.             param.ranges.def = 0.0f;

  1085.             break;

  1086.         case 8:

  1087.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1088.             param.name = "Subtract Output";

  1089.             param.ranges.def = 0.0f;

  1090.             param.ranges.max = 1.0f;

  1091.             break;

  1092.         case 9:

  1093.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1095.             param.ranges.def = 20.0f;

  1096.             break;

  1097.         case 10:

  1098.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1099.             param.name = "Hyper";

  1100.             param.ranges.def = 0.0f;

  1101.             param.ranges.max = 1.0f;

  1102.             break;

  1103.         case 11:

  1104.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1105.             param.name = "Distortion";

  1106.             param.ranges.def = 0.0f;

  1107.             break;

  1108.         case 12:

  1109.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1110.             param.name = "Analog";

  1111.             param.ranges.def = 0.0f;

  1112.             param.ranges.max = 1.0f;

  1113.             break;

  1114.         }

  1115. 

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

  1117. 

  1118.         return &param;

  1119.     }

  1120. 

  1121.     // -------------------------------------------------------------------

  1122.     // Plugin midi-program calls

  1123. 

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

  1125.     {

  1126.         if (index >= fProgramCount)

  1127.             return nullptr;

  1128. 

  1129.         static NativeMidiProgram midiProg;

  1130. 

  1131.         midiProg.bank    = 0;

  1132.         midiProg.program = index;

  1133. 

  1134.         switch (index)

  1135.         {

  1136.         case 0:

  1137.             midiProg.name = "Phaser 1";

  1138.             break;

  1139.         case 1:

  1140.             midiProg.name = "Phaser 2";

  1141.             break;

  1142.         case 2:

  1143.             midiProg.name = "Phaser 3";

  1144.             break;

  1145.         case 3:

  1146.             midiProg.name = "Phaser 4";

  1147.             break;

  1148.         case 4:

  1149.             midiProg.name = "Phaser 5";

  1150.             break;

  1151.         case 5:

  1152.             midiProg.name = "Phaser 6";

  1153.             break;

  1154.         case 6:

  1155.             midiProg.name = "APhaser 1";

  1156.             break;

  1157.         case 7:

  1158.             midiProg.name = "APhaser 2";

  1159.             break;

  1160.         case 8:

  1161.             midiProg.name = "APhaser 3";

  1162.             break;

  1163.         case 9:

  1164.             midiProg.name = "APhaser 4";

  1165.             break;

  1166.         case 10:

  1167.             midiProg.name = "APhaser 5";

  1168.             break;

  1169.         case 11:

  1170.             midiProg.name = "APhaser 6";

  1171.             break;

  1172.         default:

  1173.             midiProg.name = nullptr;

  1174.             break;

  1175.         }

  1176. 

  1177.         return &midiProg;

  1178.     }

  1179. 

  1180.     // -------------------------------------------------------------------

  1181. 

  1182.     PluginClassEND(FxPhaserPlugin)

  1183.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1184. };

  1185. 

  1186. // -----------------------------------------------------------------------

  1187. 

  1188. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1189. {

  1190. public:

  1191.     FxReverbPlugin(const NativeHostDescriptor* const host)

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

  1193. 

  1194. protected:

  1195.     // -------------------------------------------------------------------

  1196.     // Plugin parameter calls

  1197. 

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

  1199.     {

  1200.         if (index >= fParamCount)

  1201.             return nullptr;

  1202. 

  1203.         static NativeParameter param;

  1204.         static NativeParameterScalePoint scalePoints[3];

  1205. 

  1206.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1207. 

  1208.         param.name = nullptr;

  1209.         param.unit = nullptr;

  1210.         param.ranges.def       = 1.0f;

  1211.         param.ranges.min       = 0.0f;

  1212.         param.ranges.max       = 127.0f;

  1213.         param.ranges.step      = 1.0f;

  1214.         param.ranges.stepSmall = 1.0f;

  1215.         param.ranges.stepLarge = 20.0f;

  1216.         param.scalePointCount  = 0;

  1217.         param.scalePoints      = nullptr;

  1218. 

  1219.         switch (index)

  1220.         {

  1221.         case 0:

  1222.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1223.             param.name = "Time";

  1224.             param.ranges.def = 63.0f;

  1225.             break;

  1226.         case 1:

  1227.             param.name = "Delay";

  1228.             param.ranges.def = 24.0f;

  1229.             break;

  1230.         case 2:

  1231.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1232.             param.name = "Feedback";

  1233.             param.ranges.def = 0.0f;

  1234.             break;

  1235.         case 3:

  1236.             hints = 0x0;

  1237.             param.name = "bw";

  1238.             break;

  1239.         case 4:

  1240.             hints = 0x0;

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

  1242.             break;

  1243.         case 5:

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

  1245.             param.ranges.def = 85.0f;

  1246.             break;

  1247.         case 6:

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

  1249.             param.ranges.def = 5.0f;

  1250.             break;

  1251.         case 7:

  1252.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1253.             param.name = "Damp";

  1254.             param.ranges.def = 83.0f;

  1255.             param.ranges.min = 64.0f;

  1256.             break;

  1257.         case 8:

  1258.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1259.             param.name = "Type";

  1260.             param.ranges.def = 1.0f;

  1261.             param.ranges.max = 2.0f;

  1262.             param.scalePointCount = 3;

  1263.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1270.             break;

  1271.         case 9:

  1272.             param.name = "Room size";

  1273.             param.ranges.def = 64.0f;

  1274.             param.ranges.min = 1.0f;

  1275.             break;

  1276.         case 10:

  1277.             param.name = "Bandwidth";

  1278.             param.ranges.def = 20.0f;

  1279.             break;

  1280.         }

  1281. 

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

  1283. 

  1284.         return &param;

  1285.     }

  1286. 

  1287.     // -------------------------------------------------------------------

  1288.     // Plugin midi-program calls

  1289. 

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

  1291.     {

  1292.         if (index >= fProgramCount)

  1293.             return nullptr;

  1294. 

  1295.         static NativeMidiProgram midiProg;

  1296. 

  1297.         midiProg.bank    = 0;

  1298.         midiProg.program = index;

  1299. 

  1300.         switch (index)

  1301.         {

  1302.         case 0:

  1303.             midiProg.name = "Cathedral1";

  1304.             break;

  1305.         case 1:

  1306.             midiProg.name = "Cathedral2";

  1307.             break;

  1308.         case 2:

  1309.             midiProg.name = "Cathedral3";

  1310.             break;

  1311.         case 3:

  1312.             midiProg.name = "Hall1";

  1313.             break;

  1314.         case 4:

  1315.             midiProg.name = "Hall2";

  1316.             break;

  1317.         case 5:

  1318.             midiProg.name = "Room1";

  1319.             break;

  1320.         case 6:

  1321.             midiProg.name = "Room2";

  1322.             break;

  1323.         case 7:

  1324.             midiProg.name = "Basement";

  1325.             break;

  1326.         case 8:

  1327.             midiProg.name = "Tunnel";

  1328.             break;

  1329.         case 9:

  1330.             midiProg.name = "Echoed1";

  1331.             break;

  1332.         case 10:

  1333.             midiProg.name = "Echoed2";

  1334.             break;

  1335.         case 11:

  1336.             midiProg.name = "VeryLong1";

  1337.             break;

  1338.         case 12:

  1339.             midiProg.name = "VeryLong2";

  1340.             break;

  1341.         default:

  1342.             midiProg.name = nullptr;

  1343.             break;

  1344.         }

  1345. 

  1346.         return &midiProg;

  1347.     }

  1348. 

  1349.     // -------------------------------------------------------------------

  1350. 

  1351.     PluginClassEND(FxReverbPlugin)

  1352.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1353. };

  1354. 

  1355. // -----------------------------------------------------------------------

  1356. 

  1357. static const NativePluginDescriptor fxAlienWahDesc = {

  1358.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1360.                                                   |NATIVE_PLUGIN_USES_PANNING

  1361.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1362.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1363.     /* audioIns  */ 2,

  1364.     /* audioOuts */ 2,

  1365.     /* midiIns   */ 0,

  1366.     /* midiOuts  */ 0,

  1367.     /* paramIns  */ 11-2,

  1368.     /* paramOuts */ 0,

  1369.     /* name      */ "ZynAlienWah",

  1370.     /* label     */ "zynalienwah",

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

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

  1373.     PluginDescriptorFILL(FxAlienWahPlugin)

  1374. };

  1375. 

  1376. static const NativePluginDescriptor fxChorusDesc = {

  1377.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1379.                                                   |NATIVE_PLUGIN_USES_PANNING

  1380.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1381.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1382.     /* audioIns  */ 2,

  1383.     /* audioOuts */ 2,

  1384.     /* midiIns   */ 0,

  1385.     /* midiOuts  */ 0,

  1386.     /* paramIns  */ 12-2,

  1387.     /* paramOuts */ 0,

  1388.     /* name      */ "ZynChorus",

  1389.     /* label     */ "zynchorus",

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

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

  1392.     PluginDescriptorFILL(FxChorusPlugin)

  1393. };

  1394. 

  1395. static const NativePluginDescriptor fxDistortionDesc = {

  1396.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1398.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1399.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1400.     /* audioIns  */ 2,

  1401.     /* audioOuts */ 2,

  1402.     /* midiIns   */ 0,

  1403.     /* midiOuts  */ 0,

  1404.     /* paramIns  */ 11-2,

  1405.     /* paramOuts */ 0,

  1406.     /* name      */ "ZynDistortion",

  1407.     /* label     */ "zyndistortion",

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

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

  1410.     PluginDescriptorFILL(FxDistortionPlugin)

  1411. };

  1412. 

  1413. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1414.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1416.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1417.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1418.     /* audioIns  */ 2,

  1419.     /* audioOuts */ 2,

  1420.     /* midiIns   */ 0,

  1421.     /* midiOuts  */ 0,

  1422.     /* paramIns  */ 10-2,

  1423.     /* paramOuts */ 0,

  1424.     /* name      */ "ZynDynamicFilter",

  1425.     /* label     */ "zyndynamicfilter",

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

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

  1428.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1429. };

  1430. 

  1431. static const NativePluginDescriptor fxEchoDesc = {

  1432.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1434.                                                   |NATIVE_PLUGIN_USES_PANNING

  1435.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1436.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1437.     /* audioIns  */ 2,

  1438.     /* audioOuts */ 2,

  1439.     /* midiIns   */ 0,

  1440.     /* midiOuts  */ 0,

  1441.     /* paramIns  */ 7-2,

  1442.     /* paramOuts */ 0,

  1443.     /* name      */ "ZynEcho",

  1444.     /* label     */ "zynecho",

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

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

  1447.     PluginDescriptorFILL(FxEchoPlugin)

  1448. };

  1449. 

  1450. static const NativePluginDescriptor fxPhaserDesc = {

  1451.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1453.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1454.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1455.     /* audioIns  */ 2,

  1456.     /* audioOuts */ 2,

  1457.     /* midiIns   */ 0,

  1458.     /* midiOuts  */ 0,

  1459.     /* paramIns  */ 15-2,

  1460.     /* paramOuts */ 0,

  1461.     /* name      */ "ZynPhaser",

  1462.     /* label     */ "zynphaser",

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

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

  1465.     PluginDescriptorFILL(FxPhaserPlugin)

  1466. };

  1467. 

  1468. static const NativePluginDescriptor fxReverbDesc = {

  1469.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1471.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1472.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1473.     /* audioIns  */ 2,

  1474.     /* audioOuts */ 2,

  1475.     /* midiIns   */ 0,

  1476.     /* midiOuts  */ 0,

  1477.     /* paramIns  */ 13-2,

  1478.     /* paramOuts */ 0,

  1479.     /* name      */ "ZynReverb",

  1480.     /* label     */ "zynreverb",

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

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

  1483.     PluginDescriptorFILL(FxReverbPlugin)

  1484. };

  1485. 

  1486. // -----------------------------------------------------------------------

  1487. 

  1488. CARLA_EXPORT

  1489. void carla_register_native_plugin_zynaddsubfx_fx();

  1490. 

  1491. CARLA_EXPORT

  1492. void carla_register_native_plugin_zynaddsubfx_fx()

  1493. {

  1494.     carla_register_native_plugin(&fxAlienWahDesc);

  1495.     carla_register_native_plugin(&fxChorusDesc);

  1496.     carla_register_native_plugin(&fxDistortionDesc);

  1497.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1498.     carla_register_native_plugin(&fxEchoDesc);

  1499.     carla_register_native_plugin(&fxPhaserDesc);

  1500.     carla_register_native_plugin(&fxReverbDesc);

  1501. }

  1502. 

  1503. // -----------------------------------------------------------------------