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

1503 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 "water/maths/MathsFunctions.h"

  49. 

  50. using water::roundToIntAccurate;

  51. 

  52. using namespace zyncarla;

  53. 

  54. // -----------------------------------------------------------------------

  55. 

  56. template<class ZynFX>

  57. class FxAbstractPlugin : public NativePluginClass

  58. {

  59. protected:

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

  61.         : NativePluginClass(host),

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

  63.           fProgramCount(programCount),

  64.           fParamValues(new uchar[paramCount]),

  65.           fParamsChanged(new bool[paramCount]),

  66.           fNextProgram(-1),

  67.           fBufferSize(getBufferSize()),

  68.           fSampleRate(getSampleRate()),

  69.           fFilterParams(nullptr),

  70.           fEffect(nullptr),

  71.           efxoutl(nullptr),

  72.           efxoutr(nullptr),

  73.           fAllocator()

  74.     {

  75.         efxoutl = new float[fBufferSize];

  76.         efxoutr = new float[fBufferSize];

  77.         carla_zeroFloats(efxoutl, fBufferSize);

  78.         carla_zeroFloats(efxoutr, fBufferSize);

  79. 

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

  81. 

  82.         doReinit(true);

  83.     }

  84. 

  85.     ~FxAbstractPlugin() override

  86.     {

  87.         if (efxoutl != nullptr)

  88.         {

  89.             delete[] efxoutl;

  90.             efxoutl = nullptr;

  91.         }

  92. 

  93.         if (efxoutr != nullptr)

  94.         {

  95.             delete[] efxoutr;

  96.             efxoutr = nullptr;

  97.         }

  98. 

  99.         if (fEffect != nullptr)

  100.         {

  101.             delete fEffect;

  102.             fEffect = nullptr;

  103.         }

  104.     }

  105. 

  106.     // -------------------------------------------------------------------

  107.     // Plugin parameter calls

  108. 

  109.     uint32_t getParameterCount() const final

  110.     {

  111.         return fParamCount;

  112.     }

  113. 

  114.     float getParameterValue(const uint32_t index) const final

  115.     {

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

  117.     }

  118. 

  119.     // -------------------------------------------------------------------

  120.     // Plugin midi-program calls

  121. 

  122.     uint32_t getMidiProgramCount() const final

  123.     {

  124.         return fProgramCount;

  125.     }

  126. 

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

  128.     // Plugin state calls

  129. 

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

  131.     {

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

  133. 

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

  135.         fParamsChanged[index] = true;

  136.     }

  137. 

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

  139.     {

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

  141.     }

  142. 

  143.     // -------------------------------------------------------------------

  144.     // Plugin process calls

  145. 

  146.     void activate() final

  147.     {

  148.         fEffect->cleanup();

  149.     }

  150. 

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

  152.     {

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

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

  155.         else

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

  157. 

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

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

  160.         else

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

  162. 

  163.         const int32_t nextProgram = fNextProgram;

  164.         fNextProgram = -1;

  165. 

  166.         if (nextProgram >= 0)

  167.         {

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

  169. 

  170.             // reset volume and pan

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

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

  173. 

  174.             // ignore next

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

  176.         }

  177.         else

  178.         {

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

  180.             {

  181.                 if (! fParamsChanged[i])

  182.                     continue;

  183. 

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

  185.                 fParamsChanged[i] = false;

  186.             }

  187.         }

  188. 

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

  190. 

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

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

  193.     }

  194. 

  195.     // -------------------------------------------------------------------

  196.     // Plugin dispatcher

  197. 

  198.     void bufferSizeChanged(const uint32_t bufferSize) final

  199.     {

  200.         if (fBufferSize == bufferSize)

  201.             return;

  202. 

  203.         fBufferSize = bufferSize;

  204. 

  205.         delete[] efxoutl;

  206.         delete[] efxoutr;

  207.         efxoutl = new float[bufferSize];

  208.         efxoutr = new float[bufferSize];

  209.         carla_zeroFloats(efxoutl, bufferSize);

  210.         carla_zeroFloats(efxoutr, bufferSize);

  211. 

  212.         doReinit(false);

  213.     }

  214. 

  215.     void sampleRateChanged(const double sampleRate) final

  216.     {

  217.         if (carla_isEqual(fSampleRate, sampleRate))

  218.             return;

  219. 

  220.         fSampleRate = sampleRate;

  221. 

  222.         doReinit(false);

  223.     }

  224. 

  225.     void doReinit(const bool firstInit)

  226.     {

  227.         uchar params[fParamCount];

  228. 

  229.         if (fEffect != nullptr)

  230.         {

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

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

  233. 

  234.             delete fEffect;

  235.         }

  236. 

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

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

  239. 

  240.         fEffect = new ZynFX(pars);

  241. 

  242.         if (firstInit)

  243.         {

  244.             fEffect->setpreset(0);

  245. 

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

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

  248.         }

  249.         else

  250.         {

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

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

  253.         }

  254. 

  255.         // reset volume and pan

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

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

  258.     }

  259. 

  260.     // -------------------------------------------------------------------

  261. 

  262.     const uint32_t fParamCount;

  263.     const uint32_t fProgramCount;

  264. 

  265.     uchar* const fParamValues;

  266.     bool*  const fParamsChanged;

  267.     int32_t      fNextProgram;

  268. 

  269.     uint32_t fBufferSize;

  270.     double   fSampleRate;

  271. 

  272.     FilterParams fFilterParams;

  273.     Effect* fEffect;

  274.     float*  efxoutl;

  275.     float*  efxoutr;

  276. 

  277.     AllocatorClass fAllocator;

  278. 

  279.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAbstractPlugin)

  280. };

  281. 

  282. // -----------------------------------------------------------------------

  283. 

  284. class FxAlienWahPlugin : public FxAbstractPlugin<Alienwah>

  285. {

  286. public:

  287.     FxAlienWahPlugin(const NativeHostDescriptor* const host)

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

  289. 

  290. protected:

  291.     // -------------------------------------------------------------------

  292.     // Plugin parameter calls

  293. 

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

  295.     {

  296.         if (index >= fParamCount)

  297.             return nullptr;

  298. 

  299.         static NativeParameter param;

  300.         static NativeParameterScalePoint scalePoints[2];

  301. 

  302.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  303. 

  304.         param.name = nullptr;

  305.         param.unit = nullptr;

  306.         param.ranges.def       = 1.0f;

  307.         param.ranges.min       = 0.0f;

  308.         param.ranges.max       = 127.0f;

  309.         param.ranges.step      = 1.0f;

  310.         param.ranges.stepSmall = 1.0f;

  311.         param.ranges.stepLarge = 20.0f;

  312.         param.scalePointCount  = 0;

  313.         param.scalePoints      = nullptr;

  314. 

  315.         switch (index)

  316.         {

  317.         case 0:

  318.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  319.             param.name = "LFO Frequency";

  320.             param.ranges.def = 70.0f;

  321.             break;

  322.         case 1:

  323.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  324.             param.name = "LFO Randomness";

  325.             param.ranges.def = 0.0f;

  326.             break;

  327.         case 2:

  328.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  329.             param.name = "LFO Type";

  330.             param.ranges.def = 0.0f;

  331.             param.ranges.max = 1.0f;

  332.             param.scalePointCount = 2;

  333.             param.scalePoints     = scalePoints;

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

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

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

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

  338.             break;

  339.         case 3:

  340.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  341.             param.name = "LFO Stereo";

  342.             param.ranges.def = 62.0f;

  343.             break;

  344.         case 4:

  345.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  346.             param.name = "Depth";

  347.             param.ranges.def = 60.0f;

  348.             break;

  349.         case 5:

  350.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  351.             param.name = "Feedback";

  352.             param.ranges.def = 105.0f;

  353.             break;

  354.         case 6:

  355.             param.name = "Delay";

  356.             param.ranges.def = 25.0f;

  357.             param.ranges.min = 1.0f;

  358.             param.ranges.max = 100.0f;

  359.             break;

  360.         case 7:

  361.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  363.             param.ranges.def = 0.0f;

  364.             break;

  365.         case 8:

  366.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  367.             param.name = "Phase";

  368.             param.ranges.def = 64.0f;

  369.             break;

  370.         }

  371. 

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

  373. 

  374.         return &param;

  375.     }

  376. 

  377.     // -------------------------------------------------------------------

  378.     // Plugin midi-program calls

  379. 

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

  381.     {

  382.         if (index >= fProgramCount)

  383.             return nullptr;

  384. 

  385.         static NativeMidiProgram midiProg;

  386. 

  387.         midiProg.bank    = 0;

  388.         midiProg.program = index;

  389. 

  390.         switch (index)

  391.         {

  392.         case 0:

  393.             midiProg.name = "AlienWah1";

  394.             break;

  395.         case 1:

  396.             midiProg.name = "AlienWah2";

  397.             break;

  398.         case 2:

  399.             midiProg.name = "AlienWah3";

  400.             break;

  401.         case 3:

  402.             midiProg.name = "AlienWah4";

  403.             break;

  404.         default:

  405.             midiProg.name = nullptr;

  406.             break;

  407.         }

  408. 

  409.         return &midiProg;

  410.     }

  411. 

  412.     // -------------------------------------------------------------------

  413. 

  414.     PluginClassEND(FxAlienWahPlugin)

  415.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxAlienWahPlugin)

  416. };

  417. 

  418. // -----------------------------------------------------------------------

  419. 

  420. class FxChorusPlugin : public FxAbstractPlugin<Chorus>

  421. {

  422. public:

  423.     FxChorusPlugin(const NativeHostDescriptor* const host)

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

  425. 

  426. protected:

  427.     // -------------------------------------------------------------------

  428.     // Plugin parameter calls

  429. 

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

  431.     {

  432.         if (index >= fParamCount)

  433.             return nullptr;

  434. 

  435.         static NativeParameter param;

  436.         static NativeParameterScalePoint scalePoints[2];

  437. 

  438.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  439. 

  440.         param.name = nullptr;

  441.         param.unit = nullptr;

  442.         param.ranges.def       = 1.0f;

  443.         param.ranges.min       = 0.0f;

  444.         param.ranges.max       = 127.0f;

  445.         param.ranges.step      = 1.0f;

  446.         param.ranges.stepSmall = 1.0f;

  447.         param.ranges.stepLarge = 20.0f;

  448.         param.scalePointCount  = 0;

  449.         param.scalePoints      = nullptr;

  450. 

  451.         switch (index)

  452.         {

  453.         case 0:

  454.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  455.             param.name = "LFO Frequency";

  456.             param.ranges.def = 50.0f;

  457.             break;

  458.         case 1:

  459.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  460.             param.name = "LFO Randomness";

  461.             param.ranges.def = 0.0f;

  462.             break;

  463.         case 2:

  464.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  465.             param.name = "LFO Type";

  466.             param.ranges.def = 0.0f;

  467.             param.ranges.max = 1.0f;

  468.             param.scalePointCount = 2;

  469.             param.scalePoints     = scalePoints;

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

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

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

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

  474.             break;

  475.         case 3:

  476.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  477.             param.name = "LFO Stereo";

  478.             param.ranges.def = 90.0f;

  479.             break;

  480.         case 4:

  481.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  482.             param.name = "Depth";

  483.             param.ranges.def = 40.0f;

  484.             break;

  485.         case 5:

  486.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  487.             param.name = "Delay";

  488.             param.ranges.def = 85.0f;

  489.             break;

  490.         case 6:

  491.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  492.             param.name = "Feedback";

  493.             param.ranges.def = 64.0f;

  494.             break;

  495.         case 7:

  496.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  498.             param.ranges.def = 119.0f;

  499.             break;

  500.         case 8:

  501.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  502.             param.name = "Flange Mode";

  503.             param.ranges.def = 0.0f;

  504.             param.ranges.max = 1.0f;

  505.             break;

  506.         case 9:

  507.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  508.             param.name = "Subtract Output";

  509.             param.ranges.def = 0.0f;

  510.             param.ranges.max = 1.0f;

  511.             break;

  512.         }

  513. 

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

  515. 

  516.         return &param;

  517.     }

  518. 

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

  520.     // Plugin midi-program calls

  521. 

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

  523.     {

  524.         if (index >= fProgramCount)

  525.             return nullptr;

  526. 

  527.         static NativeMidiProgram midiProg;

  528. 

  529.         midiProg.bank    = 0;

  530.         midiProg.program = index;

  531. 

  532.         switch (index)

  533.         {

  534.         case 0:

  535.             midiProg.name = "Chorus1";

  536.             break;

  537.         case 1:

  538.             midiProg.name = "Chorus2";

  539.             break;

  540.         case 2:

  541.             midiProg.name = "Chorus3";

  542.             break;

  543.         case 3:

  544.             midiProg.name = "Celeste1";

  545.             break;

  546.         case 4:

  547.             midiProg.name = "Celeste2";

  548.             break;

  549.         case 5:

  550.             midiProg.name = "Flange1";

  551.             break;

  552.         case 6:

  553.             midiProg.name = "Flange2";

  554.             break;

  555.         case 7:

  556.             midiProg.name = "Flange3";

  557.             break;

  558.         case 8:

  559.             midiProg.name = "Flange4";

  560.             break;

  561.         case 9:

  562.             midiProg.name = "Flange5";

  563.             break;

  564.         default:

  565.             midiProg.name = nullptr;

  566.             break;

  567.         }

  568. 

  569.         return &midiProg;

  570.     }

  571. 

  572.     // -------------------------------------------------------------------

  573. 

  574.     PluginClassEND(FxChorusPlugin)

  575.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxChorusPlugin)

  576. };

  577. 

  578. // -----------------------------------------------------------------------

  579. 

  580. class FxDistortionPlugin : public FxAbstractPlugin<Distorsion>

  581. {

  582. public:

  583.     FxDistortionPlugin(const NativeHostDescriptor* const host)

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

  585. 

  586. protected:

  587.     // -------------------------------------------------------------------

  588.     // Plugin parameter calls

  589. 

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

  591.     {

  592.         if (index >= fParamCount)

  593.             return nullptr;

  594. 

  595.         static NativeParameter param;

  596.         static NativeParameterScalePoint scalePoints[14];

  597. 

  598.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  599. 

  600.         param.name = nullptr;

  601.         param.unit = nullptr;

  602.         param.ranges.def       = 1.0f;

  603.         param.ranges.min       = 0.0f;

  604.         param.ranges.max       = 127.0f;

  605.         param.ranges.step      = 1.0f;

  606.         param.ranges.stepSmall = 1.0f;

  607.         param.ranges.stepLarge = 20.0f;

  608.         param.scalePointCount  = 0;

  609.         param.scalePoints      = nullptr;

  610. 

  611.         switch (index)

  612.         {

  613.         case 0:

  614.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  616.             param.ranges.def = 35.0f;

  617.             break;

  618.         case 1:

  619.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  620.             param.name = "Drive";

  621.             param.ranges.def = 56.0f;

  622.             break;

  623.         case 2:

  624.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  625.             param.name = "Level";

  626.             param.ranges.def = 70.0f;

  627.             break;

  628.         case 3:

  629.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_USES_SCALEPOINTS;

  630.             param.name = "Type";

  631.             param.ranges.def = 0.0f;

  632.             param.ranges.max = 13.0f;

  633.             param.scalePointCount = 14;

  634.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  663.             break;

  664.         case 4:

  665.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  666.             param.name = "Negate";

  667.             param.ranges.def = 0.0f;

  668.             param.ranges.max = 1.0f;

  669.             break;

  670.         case 5:

  671.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  673.             param.ranges.def = 96.0f;

  674.             break;

  675.         case 6:

  676.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  678.             param.ranges.def = 0.0f;

  679.             break;

  680.         case 7:

  681.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  682.             param.name = "Stereo";

  683.             param.ranges.def = 0.0f;

  684.             param.ranges.max = 1.0f;

  685.             break;

  686.         case 8:

  687.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  689.             param.ranges.def = 0.0f;

  690.             param.ranges.max = 1.0f;

  691.             break;

  692.         }

  693. 

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

  695. 

  696.         return &param;

  697.     }

  698. 

  699.     // -------------------------------------------------------------------

  700.     // Plugin midi-program calls

  701. 

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

  703.     {

  704.         if (index >= fProgramCount)

  705.             return nullptr;

  706. 

  707.         static NativeMidiProgram midiProg;

  708. 

  709.         midiProg.bank    = 0;

  710.         midiProg.program = index;

  711. 

  712.         switch (index)

  713.         {

  714.         case 0:

  715.             midiProg.name = "Overdrive 1";

  716.             break;

  717.         case 1:

  718.             midiProg.name = "Overdrive 2";

  719.             break;

  720.         case 2:

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

  722.             break;

  723.         case 3:

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

  725.             break;

  726.         case 4:

  727.             midiProg.name = "Guitar Amp";

  728.             break;

  729.         case 5:

  730.             midiProg.name = "Quantisize";

  731.             break;

  732.         default:

  733.             midiProg.name = nullptr;

  734.             break;

  735.         }

  736. 

  737.         return &midiProg;

  738.     }

  739. 

  740.     // -------------------------------------------------------------------

  741. 

  742.     PluginClassEND(FxDistortionPlugin)

  743.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDistortionPlugin)

  744. };

  745. 

  746. // -----------------------------------------------------------------------

  747. 

  748. class FxDynamicFilterPlugin : public FxAbstractPlugin<DynamicFilter>

  749. {

  750. public:

  751.     FxDynamicFilterPlugin(const NativeHostDescriptor* const host)

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

  753. 

  754. protected:

  755.     // -------------------------------------------------------------------

  756.     // Plugin parameter calls

  757. 

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

  759.     {

  760.         if (index >= fParamCount)

  761.             return nullptr;

  762. 

  763.         static NativeParameter param;

  764.         static NativeParameterScalePoint scalePoints[2];

  765. 

  766.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  767. 

  768.         param.name = nullptr;

  769.         param.unit = nullptr;

  770.         param.ranges.def       = 1.0f;

  771.         param.ranges.min       = 0.0f;

  772.         param.ranges.max       = 127.0f;

  773.         param.ranges.step      = 1.0f;

  774.         param.ranges.stepSmall = 1.0f;

  775.         param.ranges.stepLarge = 20.0f;

  776.         param.scalePointCount  = 0;

  777.         param.scalePoints      = nullptr;

  778. 

  779.         switch (index)

  780.         {

  781.         case 0:

  782.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  783.             param.name = "LFO Frequency";

  784.             param.ranges.def = 80.0f;

  785.             break;

  786.         case 1:

  787.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  788.             param.name = "LFO Randomness";

  789.             param.ranges.def = 0.0f;

  790.             break;

  791.         case 2:

  792.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  793.             param.name = "LFO Type";

  794.             param.ranges.def = 0.0f;

  795.             param.ranges.max = 1.0f;

  796.             param.scalePointCount = 2;

  797.             param.scalePoints     = scalePoints;

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

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

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

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

  802.             break;

  803.         case 3:

  804.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  805.             param.name = "LFO Stereo";

  806.             param.ranges.def = 64.0f;

  807.             break;

  808.         case 4:

  809.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  810.             param.name = "LFO Depth";

  811.             param.ranges.def = 0.0f;

  812.             break;

  813.         case 5:

  814.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  815.             param.name = "Amp sns";

  816.             param.ranges.def = 90.0f;

  817.             break;

  818.         case 6:

  819.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

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

  821.             param.ranges.def = 0.0f;

  822.             param.ranges.max = 1.0f;

  823.             break;

  824.         case 7:

  825.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  826.             param.name = "Amp Smooth";

  827.             param.ranges.def = 60.0f;

  828.             break;

  829.         }

  830. 

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

  832. 

  833.         return &param;

  834.     }

  835. 

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

  837.     // Plugin midi-program calls

  838. 

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

  840.     {

  841.         if (index >= fProgramCount)

  842.             return nullptr;

  843. 

  844.         static NativeMidiProgram midiProg;

  845. 

  846.         midiProg.bank    = 0;

  847.         midiProg.program = index;

  848. 

  849.         switch (index)

  850.         {

  851.         case 0:

  852.             midiProg.name = "WahWah";

  853.             break;

  854.         case 1:

  855.             midiProg.name = "AutoWah";

  856.             break;

  857.         case 2:

  858.             midiProg.name = "Sweep";

  859.             break;

  860.         case 3:

  861.             midiProg.name = "VocalMorph1";

  862.             break;

  863.         case 4:

  864.             midiProg.name = "VocalMorph2";

  865.             break;

  866.         default:

  867.             midiProg.name = nullptr;

  868.             break;

  869.         }

  870. 

  871.         return &midiProg;

  872.     }

  873. 

  874.     // -------------------------------------------------------------------

  875. 

  876.     PluginClassEND(FxDynamicFilterPlugin)

  877.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxDynamicFilterPlugin)

  878. };

  879. 

  880. // -----------------------------------------------------------------------

  881. 

  882. class FxEchoPlugin : public FxAbstractPlugin<Echo>

  883. {

  884. public:

  885.     FxEchoPlugin(const NativeHostDescriptor* const host)

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

  887. 

  888. protected:

  889.     // -------------------------------------------------------------------

  890.     // Plugin parameter calls

  891. 

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

  893.     {

  894.         if (index >= fParamCount)

  895.             return nullptr;

  896. 

  897.         static NativeParameter param;

  898. 

  899.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  900. 

  901.         param.name = nullptr;

  902.         param.unit = nullptr;

  903.         param.ranges.def       = 1.0f;

  904.         param.ranges.min       = 0.0f;

  905.         param.ranges.max       = 127.0f;

  906.         param.ranges.step      = 1.0f;

  907.         param.ranges.stepSmall = 1.0f;

  908.         param.ranges.stepLarge = 20.0f;

  909.         param.scalePointCount  = 0;

  910.         param.scalePoints      = nullptr;

  911. 

  912.         switch (index)

  913.         {

  914.         case 0:

  915.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  916.             param.name = "Delay";

  917.             param.ranges.def = 35.0f;

  918.             break;

  919.         case 1:

  920.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  922.             param.ranges.def = 64.0f;

  923.             break;

  924.         case 2:

  925.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  927.             param.ranges.def = 30.0f;

  928.             break;

  929.         case 3:

  930.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  931.             param.name = "Feedback";

  932.             param.ranges.def = 59.0f;

  933.             break;

  934.         case 4:

  935.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  936.             param.name = "High Damp";

  937.             param.ranges.def = 0.0f;

  938.             break;

  939.         }

  940. 

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

  942. 

  943.         return &param;

  944.     }

  945. 

  946.     // -------------------------------------------------------------------

  947.     // Plugin midi-program calls

  948. 

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

  950.     {

  951.         if (index >= fProgramCount)

  952.             return nullptr;

  953. 

  954.         static NativeMidiProgram midiProg;

  955. 

  956.         midiProg.bank    = 0;

  957.         midiProg.program = index;

  958. 

  959.         switch (index)

  960.         {

  961.         case 0:

  962.             midiProg.name = "Echo 1";

  963.             break;

  964.         case 1:

  965.             midiProg.name = "Echo 2";

  966.             break;

  967.         case 2:

  968.             midiProg.name = "Echo 3";

  969.             break;

  970.         case 3:

  971.             midiProg.name = "Simple Echo";

  972.             break;

  973.         case 4:

  974.             midiProg.name = "Canyon";

  975.             break;

  976.         case 5:

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

  978.             break;

  979.         case 6:

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

  981.             break;

  982.         case 7:

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

  984.             break;

  985.         case 8:

  986.             midiProg.name = "Feedback Echo";

  987.             break;

  988.         default:

  989.             midiProg.name = nullptr;

  990.             break;

  991.         }

  992. 

  993.         return &midiProg;

  994.     }

  995. 

  996.     // -------------------------------------------------------------------

  997. 

  998.     PluginClassEND(FxEchoPlugin)

  999.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxEchoPlugin)

  1000. };

  1001. 

  1002. // -----------------------------------------------------------------------

  1003. 

  1004. class FxPhaserPlugin : public FxAbstractPlugin<Phaser>

  1005. {

  1006. public:

  1007.     FxPhaserPlugin(const NativeHostDescriptor* const host)

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

  1009. 

  1010. protected:

  1011.     // -------------------------------------------------------------------

  1012.     // Plugin parameter calls

  1013. 

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

  1015.     {

  1016.         if (index >= fParamCount)

  1017.             return nullptr;

  1018. 

  1019.         static NativeParameter param;

  1020.         static NativeParameterScalePoint scalePoints[2];

  1021. 

  1022.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1023. 

  1024.         param.name = nullptr;

  1025.         param.unit = nullptr;

  1026.         param.ranges.def       = 1.0f;

  1027.         param.ranges.min       = 0.0f;

  1028.         param.ranges.max       = 127.0f;

  1029.         param.ranges.step      = 1.0f;

  1030.         param.ranges.stepSmall = 1.0f;

  1031.         param.ranges.stepLarge = 20.0f;

  1032.         param.scalePointCount  = 0;

  1033.         param.scalePoints      = nullptr;

  1034. 

  1035.         switch (index)

  1036.         {

  1037.         case 0:

  1038.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1039.             param.name = "LFO Frequency";

  1040.             param.ranges.def = 36.0f;

  1041.             break;

  1042.         case 1:

  1043.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1044.             param.name = "LFO Randomness";

  1045.             param.ranges.def = 0.0f;

  1046.             break;

  1047.         case 2:

  1048.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN|NATIVE_PARAMETER_USES_SCALEPOINTS;

  1049.             param.name = "LFO Type";

  1050.             param.ranges.def = 0.0f;

  1051.             param.ranges.max = 1.0f;

  1052.             param.scalePointCount = 2;

  1053.             param.scalePoints     = scalePoints;

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

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

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

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

  1058.             break;

  1059.         case 3:

  1060.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1061.             param.name = "LFO Stereo";

  1062.             param.ranges.def = 64.0f;

  1063.             break;

  1064.         case 4:

  1065.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1066.             param.name = "Depth";

  1067.             param.ranges.def = 110.0f;

  1068.             break;

  1069.         case 5:

  1070.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1071.             param.name = "Feedback";

  1072.             param.ranges.def = 64.0f;

  1073.             break;

  1074.         case 6:

  1075.             param.name = "Stages";

  1076.             param.ranges.def = 1.0f;

  1077.             param.ranges.min = 1.0f;

  1078.             param.ranges.max = 12.0f;

  1079.             break;

  1080.         case 7:

  1081.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1083.             param.ranges.def = 0.0f;

  1084.             break;

  1085.         case 8:

  1086.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1087.             param.name = "Subtract Output";

  1088.             param.ranges.def = 0.0f;

  1089.             param.ranges.max = 1.0f;

  1090.             break;

  1091.         case 9:

  1092.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

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

  1094.             param.ranges.def = 20.0f;

  1095.             break;

  1096.         case 10:

  1097.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1098.             param.name = "Hyper";

  1099.             param.ranges.def = 0.0f;

  1100.             param.ranges.max = 1.0f;

  1101.             break;

  1102.         case 11:

  1103.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1104.             param.name = "Distortion";

  1105.             param.ranges.def = 0.0f;

  1106.             break;

  1107.         case 12:

  1108.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE|NATIVE_PARAMETER_IS_BOOLEAN;

  1109.             param.name = "Analog";

  1110.             param.ranges.def = 0.0f;

  1111.             param.ranges.max = 1.0f;

  1112.             break;

  1113.         }

  1114. 

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

  1116. 

  1117.         return &param;

  1118.     }

  1119. 

  1120.     // -------------------------------------------------------------------

  1121.     // Plugin midi-program calls

  1122. 

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

  1124.     {

  1125.         if (index >= fProgramCount)

  1126.             return nullptr;

  1127. 

  1128.         static NativeMidiProgram midiProg;

  1129. 

  1130.         midiProg.bank    = 0;

  1131.         midiProg.program = index;

  1132. 

  1133.         switch (index)

  1134.         {

  1135.         case 0:

  1136.             midiProg.name = "Phaser 1";

  1137.             break;

  1138.         case 1:

  1139.             midiProg.name = "Phaser 2";

  1140.             break;

  1141.         case 2:

  1142.             midiProg.name = "Phaser 3";

  1143.             break;

  1144.         case 3:

  1145.             midiProg.name = "Phaser 4";

  1146.             break;

  1147.         case 4:

  1148.             midiProg.name = "Phaser 5";

  1149.             break;

  1150.         case 5:

  1151.             midiProg.name = "Phaser 6";

  1152.             break;

  1153.         case 6:

  1154.             midiProg.name = "APhaser 1";

  1155.             break;

  1156.         case 7:

  1157.             midiProg.name = "APhaser 2";

  1158.             break;

  1159.         case 8:

  1160.             midiProg.name = "APhaser 3";

  1161.             break;

  1162.         case 9:

  1163.             midiProg.name = "APhaser 4";

  1164.             break;

  1165.         case 10:

  1166.             midiProg.name = "APhaser 5";

  1167.             break;

  1168.         case 11:

  1169.             midiProg.name = "APhaser 6";

  1170.             break;

  1171.         default:

  1172.             midiProg.name = nullptr;

  1173.             break;

  1174.         }

  1175. 

  1176.         return &midiProg;

  1177.     }

  1178. 

  1179.     // -------------------------------------------------------------------

  1180. 

  1181.     PluginClassEND(FxPhaserPlugin)

  1182.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxPhaserPlugin)

  1183. };

  1184. 

  1185. // -----------------------------------------------------------------------

  1186. 

  1187. class FxReverbPlugin : public FxAbstractPlugin<Reverb>

  1188. {

  1189. public:

  1190.     FxReverbPlugin(const NativeHostDescriptor* const host)

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

  1192. 

  1193. protected:

  1194.     // -------------------------------------------------------------------

  1195.     // Plugin parameter calls

  1196. 

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

  1198.     {

  1199.         if (index >= fParamCount)

  1200.             return nullptr;

  1201. 

  1202.         static NativeParameter param;

  1203.         static NativeParameterScalePoint scalePoints[3];

  1204. 

  1205.         int hints = NATIVE_PARAMETER_IS_ENABLED|NATIVE_PARAMETER_IS_INTEGER;

  1206. 

  1207.         param.name = nullptr;

  1208.         param.unit = nullptr;

  1209.         param.ranges.def       = 1.0f;

  1210.         param.ranges.min       = 0.0f;

  1211.         param.ranges.max       = 127.0f;

  1212.         param.ranges.step      = 1.0f;

  1213.         param.ranges.stepSmall = 1.0f;

  1214.         param.ranges.stepLarge = 20.0f;

  1215.         param.scalePointCount  = 0;

  1216.         param.scalePoints      = nullptr;

  1217. 

  1218.         switch (index)

  1219.         {

  1220.         case 0:

  1221.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1222.             param.name = "Time";

  1223.             param.ranges.def = 63.0f;

  1224.             break;

  1225.         case 1:

  1226.             param.name = "Delay";

  1227.             param.ranges.def = 24.0f;

  1228.             break;

  1229.         case 2:

  1230.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1231.             param.name = "Feedback";

  1232.             param.ranges.def = 0.0f;

  1233.             break;

  1234.         case 3:

  1235.             hints = 0x0;

  1236.             param.name = "bw";

  1237.             break;

  1238.         case 4:

  1239.             hints = 0x0;

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

  1241.             break;

  1242.         case 5:

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

  1244.             param.ranges.def = 85.0f;

  1245.             break;

  1246.         case 6:

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

  1248.             param.ranges.def = 5.0f;

  1249.             break;

  1250.         case 7:

  1251.             hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1252.             param.name = "Damp";

  1253.             param.ranges.def = 83.0f;

  1254.             param.ranges.min = 64.0f;

  1255.             break;

  1256.         case 8:

  1257.             hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1258.             param.name = "Type";

  1259.             param.ranges.def = 1.0f;

  1260.             param.ranges.max = 2.0f;

  1261.             param.scalePointCount = 3;

  1262.             param.scalePoints     = scalePoints;

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

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

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

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

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

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

  1269.             break;

  1270.         case 9:

  1271.             param.name = "Room size";

  1272.             param.ranges.def = 64.0f;

  1273.             param.ranges.min = 1.0f;

  1274.             break;

  1275.         case 10:

  1276.             param.name = "Bandwidth";

  1277.             param.ranges.def = 20.0f;

  1278.             break;

  1279.         }

  1280. 

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

  1282. 

  1283.         return &param;

  1284.     }

  1285. 

  1286.     // -------------------------------------------------------------------

  1287.     // Plugin midi-program calls

  1288. 

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

  1290.     {

  1291.         if (index >= fProgramCount)

  1292.             return nullptr;

  1293. 

  1294.         static NativeMidiProgram midiProg;

  1295. 

  1296.         midiProg.bank    = 0;

  1297.         midiProg.program = index;

  1298. 

  1299.         switch (index)

  1300.         {

  1301.         case 0:

  1302.             midiProg.name = "Cathedral1";

  1303.             break;

  1304.         case 1:

  1305.             midiProg.name = "Cathedral2";

  1306.             break;

  1307.         case 2:

  1308.             midiProg.name = "Cathedral3";

  1309.             break;

  1310.         case 3:

  1311.             midiProg.name = "Hall1";

  1312.             break;

  1313.         case 4:

  1314.             midiProg.name = "Hall2";

  1315.             break;

  1316.         case 5:

  1317.             midiProg.name = "Room1";

  1318.             break;

  1319.         case 6:

  1320.             midiProg.name = "Room2";

  1321.             break;

  1322.         case 7:

  1323.             midiProg.name = "Basement";

  1324.             break;

  1325.         case 8:

  1326.             midiProg.name = "Tunnel";

  1327.             break;

  1328.         case 9:

  1329.             midiProg.name = "Echoed1";

  1330.             break;

  1331.         case 10:

  1332.             midiProg.name = "Echoed2";

  1333.             break;

  1334.         case 11:

  1335.             midiProg.name = "VeryLong1";

  1336.             break;

  1337.         case 12:

  1338.             midiProg.name = "VeryLong2";

  1339.             break;

  1340.         default:

  1341.             midiProg.name = nullptr;

  1342.             break;

  1343.         }

  1344. 

  1345.         return &midiProg;

  1346.     }

  1347. 

  1348.     // -------------------------------------------------------------------

  1349. 

  1350.     PluginClassEND(FxReverbPlugin)

  1351.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FxReverbPlugin)

  1352. };

  1353. 

  1354. // -----------------------------------------------------------------------

  1355. 

  1356. static const NativePluginDescriptor fxAlienWahDesc = {

  1357.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1359.                                                   |NATIVE_PLUGIN_USES_PANNING

  1360.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1361.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1362.     /* audioIns  */ 2,

  1363.     /* audioOuts */ 2,

  1364.     /* midiIns   */ 0,

  1365.     /* midiOuts  */ 0,

  1366.     /* paramIns  */ 11-2,

  1367.     /* paramOuts */ 0,

  1368.     /* name      */ "ZynAlienWah",

  1369.     /* label     */ "zynalienwah",

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

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

  1372.     PluginDescriptorFILL(FxAlienWahPlugin)

  1373. };

  1374. 

  1375. static const NativePluginDescriptor fxChorusDesc = {

  1376.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1378.                                                   |NATIVE_PLUGIN_USES_PANNING

  1379.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1380.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1381.     /* audioIns  */ 2,

  1382.     /* audioOuts */ 2,

  1383.     /* midiIns   */ 0,

  1384.     /* midiOuts  */ 0,

  1385.     /* paramIns  */ 12-2,

  1386.     /* paramOuts */ 0,

  1387.     /* name      */ "ZynChorus",

  1388.     /* label     */ "zynchorus",

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

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

  1391.     PluginDescriptorFILL(FxChorusPlugin)

  1392. };

  1393. 

  1394. static const NativePluginDescriptor fxDistortionDesc = {

  1395.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1397.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1398.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1399.     /* audioIns  */ 2,

  1400.     /* audioOuts */ 2,

  1401.     /* midiIns   */ 0,

  1402.     /* midiOuts  */ 0,

  1403.     /* paramIns  */ 11-2,

  1404.     /* paramOuts */ 0,

  1405.     /* name      */ "ZynDistortion",

  1406.     /* label     */ "zyndistortion",

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

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

  1409.     PluginDescriptorFILL(FxDistortionPlugin)

  1410. };

  1411. 

  1412. static const NativePluginDescriptor fxDynamicFilterDesc = {

  1413.     /* category  */ NATIVE_PLUGIN_CATEGORY_FILTER,

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

  1415.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1416.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1417.     /* audioIns  */ 2,

  1418.     /* audioOuts */ 2,

  1419.     /* midiIns   */ 0,

  1420.     /* midiOuts  */ 0,

  1421.     /* paramIns  */ 10-2,

  1422.     /* paramOuts */ 0,

  1423.     /* name      */ "ZynDynamicFilter",

  1424.     /* label     */ "zyndynamicfilter",

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

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

  1427.     PluginDescriptorFILL(FxDynamicFilterPlugin)

  1428. };

  1429. 

  1430. static const NativePluginDescriptor fxEchoDesc = {

  1431.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1433.                                                   |NATIVE_PLUGIN_USES_PANNING

  1434.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1435.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1436.     /* audioIns  */ 2,

  1437.     /* audioOuts */ 2,

  1438.     /* midiIns   */ 0,

  1439.     /* midiOuts  */ 0,

  1440.     /* paramIns  */ 7-2,

  1441.     /* paramOuts */ 0,

  1442.     /* name      */ "ZynEcho",

  1443.     /* label     */ "zynecho",

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

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

  1446.     PluginDescriptorFILL(FxEchoPlugin)

  1447. };

  1448. 

  1449. static const NativePluginDescriptor fxPhaserDesc = {

  1450.     /* category  */ NATIVE_PLUGIN_CATEGORY_MODULATOR,

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

  1452.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1453.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1454.     /* audioIns  */ 2,

  1455.     /* audioOuts */ 2,

  1456.     /* midiIns   */ 0,

  1457.     /* midiOuts  */ 0,

  1458.     /* paramIns  */ 15-2,

  1459.     /* paramOuts */ 0,

  1460.     /* name      */ "ZynPhaser",

  1461.     /* label     */ "zynphaser",

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

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

  1464.     PluginDescriptorFILL(FxPhaserPlugin)

  1465. };

  1466. 

  1467. static const NativePluginDescriptor fxReverbDesc = {

  1468.     /* category  */ NATIVE_PLUGIN_CATEGORY_DELAY,

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

  1470.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS),

  1471.     /* supports  */ NATIVE_PLUGIN_SUPPORTS_NOTHING,

  1472.     /* audioIns  */ 2,

  1473.     /* audioOuts */ 2,

  1474.     /* midiIns   */ 0,

  1475.     /* midiOuts  */ 0,

  1476.     /* paramIns  */ 13-2,

  1477.     /* paramOuts */ 0,

  1478.     /* name      */ "ZynReverb",

  1479.     /* label     */ "zynreverb",

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

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

  1482.     PluginDescriptorFILL(FxReverbPlugin)

  1483. };

  1484. 

  1485. // -----------------------------------------------------------------------

  1486. 

  1487. CARLA_EXPORT

  1488. void carla_register_native_plugin_zynaddsubfx_fx();

  1489. 

  1490. CARLA_EXPORT

  1491. void carla_register_native_plugin_zynaddsubfx_fx()

  1492. {

  1493.     carla_register_native_plugin(&fxAlienWahDesc);

  1494.     carla_register_native_plugin(&fxChorusDesc);

  1495.     carla_register_native_plugin(&fxDistortionDesc);

  1496.     carla_register_native_plugin(&fxDynamicFilterDesc);

  1497.     carla_register_native_plugin(&fxEchoDesc);

  1498.     carla_register_native_plugin(&fxPhaserDesc);

  1499.     carla_register_native_plugin(&fxReverbDesc);

  1500. }

  1501. 

  1502. // -----------------------------------------------------------------------