DISTRHO
/
DPF-Plugins
mirror of https://github.com/DISTRHO/DPF-Plugins
1
0
Fork 0
Code Releases 8 Activity
Collection of DPF-based plugins for packaging
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.
30 Commits
1 Branch
87MB
Tree: f0296f30b8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f0296f30b8'
${ noResults }
DPF-Plugins/plugins/MVerb/MVerb.h

843 lines
23KB
Raw Blame History 

  1. //	Copyright (c) 2010 Martin Eastwood

  2. //  This code is distributed under the terms of the GNU General Public License

  3. 

  4. //  MVerb is free software: you can redistribute it and/or modify

  5. //  it under the terms of the GNU General Public License as published by

  6. //  the Free Software Foundation, either version 3 of the License, or

  7. //  at your option) any later version.

  8. //

  9. //  MVerb is distributed in the hope that it will be useful,

  10. //  but WITHOUT ANY WARRANTY; without even the implied warranty of

  11. //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12. //  GNU General Public License for more details.

  13. //

  14. //  You should have received a copy of the GNU General Public License

  15. //  along with this MVerb.  If not, see <http://www.gnu.org/licenses/>.

  16. 

  17. #ifndef EMVERB_H

  18. #define EMVERB_H

  19. 

  20. #include <cmath>

  21. #include <cstring>

  22. 

  23. //forward declaration

  24. template<typename T, int maxLength> class Allpass;

  25. template<typename T, int maxLength> class StaticAllpassFourTap;

  26. template<typename T, int maxLength> class StaticDelayLine;

  27. template<typename T, int maxLength> class StaticDelayLineFourTap;

  28. template<typename T, int maxLength> class StaticDelayLineEightTap;

  29. template<typename T, int OverSampleCount> class StateVariable;

  30. 

  31. template<typename T>

  32. class MVerb

  33. {

  34. private:

  35.     Allpass<T, 96000> allpass[4];

  36.     StaticAllpassFourTap<T, 96000> allpassFourTap[4];

  37.     StateVariable<T,4> bandwidthFilter[2];

  38.     StateVariable<T,4> damping[2];

  39.     StaticDelayLine<T, 96000> predelay;

  40.     StaticDelayLineFourTap<T, 96000> staticDelayLine[4];

  41.     StaticDelayLineEightTap<T, 96000> earlyReflectionsDelayLine[2];

  42.     T SampleRate, DampingFreq, Density1, Density2, BandwidthFreq, PreDelayTime, Decay, Gain, Mix, EarlyMix, Size;

  43.     T MixSmooth, EarlyLateSmooth, BandwidthSmooth, DampingSmooth, PredelaySmooth, SizeSmooth, DensitySmooth, DecaySmooth;

  44.     T PreviousLeftTank, PreviousRightTank;

  45.     int ControlRate, ControlRateCounter;

  46. 

  47. public:

  48.     enum

  49.     {

  50.         DAMPINGFREQ=0,

  51.         DENSITY,

  52.         BANDWIDTHFREQ,

  53.         DECAY,

  54.         PREDELAY,

  55.         SIZE,

  56.         GAIN,

  57.         MIX,

  58.         EARLYMIX,

  59.         NUM_PARAMS

  60.     };

  61. 

  62.     MVerb(){

  63.         DampingFreq = 18000.;

  64.         BandwidthFreq = 18000.;

  65.         SampleRate = 44100.;

  66.         Decay = 0.5;

  67.         Gain = 1.;

  68.         Mix = 1.;

  69.         Size = 1.;

  70.         EarlyMix = 1.;

  71.         PreviousLeftTank = 0.;

  72.         PreviousRightTank = 0.;

  73.         PreDelayTime = 100 * (SampleRate / 1000);

  74.         MixSmooth = EarlyLateSmooth = BandwidthSmooth = DampingSmooth = PredelaySmooth = SizeSmooth = DecaySmooth = DensitySmooth = 0.;

  75.         ControlRate = SampleRate / 1000;

  76.         ControlRateCounter = 0;

  77.         reset();

  78.     }

  79. 

  80.     ~MVerb(){

  81.         //nowt to do here

  82.     }

  83. 

  84.     void process(const T **inputs, T **outputs, int sampleFrames){

  85.         T OneOverSampleFrames = 1. / sampleFrames;

  86.         T MixDelta	= (Mix - MixSmooth) * OneOverSampleFrames;

  87.         T EarlyLateDelta = (EarlyMix - EarlyLateSmooth) * OneOverSampleFrames;

  88.         T BandwidthDelta = (((BandwidthFreq * 18400.) + 100.) - BandwidthSmooth) * OneOverSampleFrames;

  89.         T DampingDelta = (((DampingFreq * 18400.) + 100.) - DampingSmooth) * OneOverSampleFrames;

  90.         T PredelayDelta = ((PreDelayTime * 200 * (SampleRate / 1000)) - PredelaySmooth) * OneOverSampleFrames;

  91.         T SizeDelta	= (Size - SizeSmooth) * OneOverSampleFrames;

  92.         T DecayDelta = (((0.7995f * Decay) + 0.005) - DecaySmooth) * OneOverSampleFrames;

  93.         T DensityDelta = (((0.7995f * Density1) + 0.005) - DensitySmooth) * OneOverSampleFrames;

  94.         for(int i=0;i<sampleFrames;++i){

  95.             T left = inputs[0][i];

  96.             T right = inputs[1][i];

  97.             MixSmooth += MixDelta;

  98.             EarlyLateSmooth += EarlyLateDelta;

  99.             BandwidthSmooth += BandwidthDelta;

  100.             DampingSmooth += DampingDelta;

  101.             PredelaySmooth += PredelayDelta;

  102.             SizeSmooth += SizeDelta;

  103.             DecaySmooth += DecayDelta;

  104.             DensitySmooth += DensityDelta;

  105.             if (ControlRateCounter >= ControlRate){

  106.                 ControlRateCounter = 0;

  107.                 bandwidthFilter[0].Frequency(BandwidthSmooth);

  108.                 bandwidthFilter[1].Frequency(BandwidthSmooth);

  109.                 damping[0].Frequency(DampingSmooth);

  110.                 damping[1].Frequency(DampingSmooth);

  111.             }

  112.             ++ControlRateCounter;

  113.             predelay.SetLength(PredelaySmooth);

  114.             Density2 = DecaySmooth + 0.15;

  115.             if (Density2 > 0.5)

  116.                 Density2 = 0.5;

  117.             if (Density2 < 0.25)

  118.                 Density2 = 0.25;

  119.             allpassFourTap[1].SetFeedback(Density2);

  120.             allpassFourTap[3].SetFeedback(Density2);

  121.             allpassFourTap[0].SetFeedback(Density1);

  122.             allpassFourTap[2].SetFeedback(Density1);

  123.             T bandwidthLeft = bandwidthFilter[0](left) ;

  124.             T bandwidthRight = bandwidthFilter[1](right) ;

  125.             T earlyReflectionsL = earlyReflectionsDelayLine[0] ( bandwidthLeft * 0.5 + bandwidthRight * 0.3 )

  126.                     + earlyReflectionsDelayLine[0].GetIndex(2) * 0.6

  127.                     + earlyReflectionsDelayLine[0].GetIndex(3) * 0.4

  128.                     + earlyReflectionsDelayLine[0].GetIndex(4) * 0.3

  129.                     + earlyReflectionsDelayLine[0].GetIndex(5) * 0.3

  130.                     + earlyReflectionsDelayLine[0].GetIndex(6) * 0.1

  131.                     + earlyReflectionsDelayLine[0].GetIndex(7) * 0.1

  132.                     + ( bandwidthLeft * 0.4 + bandwidthRight * 0.2 ) * 0.5 ;

  133.             T earlyReflectionsR = earlyReflectionsDelayLine[1] ( bandwidthLeft * 0.3 + bandwidthRight * 0.5 )

  134.                     + earlyReflectionsDelayLine[1].GetIndex(2) * 0.6

  135.                     + earlyReflectionsDelayLine[1].GetIndex(3) * 0.4

  136.                     + earlyReflectionsDelayLine[1].GetIndex(4) * 0.3

  137.                     + earlyReflectionsDelayLine[1].GetIndex(5) * 0.3

  138.                     + earlyReflectionsDelayLine[1].GetIndex(6) * 0.1

  139.                     + earlyReflectionsDelayLine[1].GetIndex(7) * 0.1

  140.                     + ( bandwidthLeft * 0.2 + bandwidthRight * 0.4 ) * 0.5 ;

  141.             T predelayMonoInput = predelay(( bandwidthRight + bandwidthLeft ) * 0.5f);

  142.             T smearedInput = predelayMonoInput;

  143.             for(int j=0;j<4;j++)

  144.                 smearedInput = allpass[j] ( smearedInput );

  145.             T leftTank = allpassFourTap[0] ( smearedInput + PreviousRightTank ) ;

  146.             leftTank = staticDelayLine[0] (leftTank);

  147.             leftTank = damping[0](leftTank);

  148.             leftTank = allpassFourTap[1](leftTank);

  149.             leftTank = staticDelayLine[1](leftTank);

  150.             T rightTank = allpassFourTap[2] (smearedInput + PreviousLeftTank) ;

  151.             rightTank = staticDelayLine[2](rightTank);

  152.             rightTank = damping[1] (rightTank);

  153.             rightTank = allpassFourTap[3](rightTank);

  154.             rightTank = staticDelayLine[3](rightTank);

  155.             PreviousLeftTank = leftTank * DecaySmooth;

  156.             PreviousRightTank = rightTank * DecaySmooth;

  157.             T accumulatorL = (0.6*staticDelayLine[2].GetIndex(1))

  158.                     +(0.6*staticDelayLine[2].GetIndex(2))

  159.                     -(0.6*allpassFourTap[3].GetIndex(1))

  160.                     +(0.6*staticDelayLine[3].GetIndex(1))

  161.                     -(0.6*staticDelayLine[0].GetIndex(1))

  162.                     -(0.6*allpassFourTap[1].GetIndex(1))

  163.                     -(0.6*staticDelayLine[1].GetIndex(1));

  164.             T accumulatorR = (0.6*staticDelayLine[0].GetIndex(2))

  165.                     +(0.6*staticDelayLine[0].GetIndex(3))

  166.                     -(0.6*allpassFourTap[1].GetIndex(2))

  167.                     +(0.6*staticDelayLine[1].GetIndex(2))

  168.                     -(0.6*staticDelayLine[2].GetIndex(3))

  169.                     -(0.6*allpassFourTap[3].GetIndex(2))

  170.                     -(0.6*staticDelayLine[3].GetIndex(2));

  171.             accumulatorL = ((accumulatorL * EarlyMix) + ((1 - EarlyMix) * earlyReflectionsL));

  172.             accumulatorR = ((accumulatorR * EarlyMix) + ((1 - EarlyMix) * earlyReflectionsR));

  173.             left = ( left + MixSmooth * ( accumulatorL - left ) ) * Gain;

  174.             right = ( right + MixSmooth * ( accumulatorR - right ) ) * Gain;

  175.             outputs[0][i] = left;

  176.             outputs[1][i] = right;

  177.         }

  178.     }

  179. 

  180.     void reset(){

  181.         ControlRateCounter = 0;

  182.         bandwidthFilter[0].SetSampleRate (SampleRate );

  183.         bandwidthFilter[1].SetSampleRate (SampleRate );

  184.         bandwidthFilter[0].Reset();

  185.         bandwidthFilter[1].Reset();

  186.         damping[0].SetSampleRate (SampleRate );

  187.         damping[1].SetSampleRate (SampleRate );

  188.         damping[0].Reset();

  189.         damping[1].Reset();

  190.         predelay.Clear();

  191.         predelay.SetLength(PreDelayTime);

  192.         allpass[0].Clear();

  193.         allpass[1].Clear();

  194.         allpass[2].Clear();

  195.         allpass[3].Clear();

  196.         allpass[0].SetLength (0.0048 * SampleRate);

  197.         allpass[1].SetLength (0.0036 * SampleRate);

  198.         allpass[2].SetLength (0.0127 * SampleRate);

  199.         allpass[3].SetLength (0.0093 * SampleRate);

  200.         allpass[0].SetFeedback (0.75);

  201.         allpass[1].SetFeedback (0.75);

  202.         allpass[2].SetFeedback (0.625);

  203.         allpass[3].SetFeedback (0.625);

  204.         allpassFourTap[0].Clear();

  205.         allpassFourTap[1].Clear();

  206.         allpassFourTap[2].Clear();

  207.         allpassFourTap[3].Clear();

  208.         allpassFourTap[0].SetLength(0.020 * SampleRate * Size);

  209.         allpassFourTap[1].SetLength(0.060 * SampleRate * Size);

  210.         allpassFourTap[2].SetLength(0.030 * SampleRate * Size);

  211.         allpassFourTap[3].SetLength(0.089 * SampleRate * Size);

  212.         allpassFourTap[0].SetFeedback(Density1);

  213.         allpassFourTap[1].SetFeedback(Density2);

  214.         allpassFourTap[2].SetFeedback(Density1);

  215.         allpassFourTap[3].SetFeedback(Density2);

  216.         allpassFourTap[0].SetIndex(0,0,0,0);

  217.         allpassFourTap[1].SetIndex(0,0.006 * SampleRate * Size, 0.041 * SampleRate * Size, 0);

  218.         allpassFourTap[2].SetIndex(0,0,0,0);

  219.         allpassFourTap[3].SetIndex(0,0.031 * SampleRate * Size, 0.011 * SampleRate * Size, 0);

  220.         staticDelayLine[0].Clear();

  221.         staticDelayLine[1].Clear();

  222.         staticDelayLine[2].Clear();

  223.         staticDelayLine[3].Clear();

  224.         staticDelayLine[0].SetLength(0.15 * SampleRate * Size);

  225.         staticDelayLine[1].SetLength(0.12 * SampleRate * Size);

  226.         staticDelayLine[2].SetLength(0.14 * SampleRate * Size);

  227.         staticDelayLine[3].SetLength(0.11 * SampleRate * Size);

  228.         staticDelayLine[0].SetIndex(0, 0.067 * SampleRate * Size, 0.011 * SampleRate * Size , 0.121 * SampleRate * Size);

  229.         staticDelayLine[1].SetIndex(0, 0.036 * SampleRate * Size, 0.089 * SampleRate * Size , 0);

  230.         staticDelayLine[2].SetIndex(0, 0.0089 * SampleRate * Size, 0.099 * SampleRate * Size , 0);

  231.         staticDelayLine[3].SetIndex(0, 0.067 * SampleRate * Size, 0.0041 * SampleRate * Size , 0);

  232.         earlyReflectionsDelayLine[0].Clear();

  233.         earlyReflectionsDelayLine[1].Clear();

  234.         earlyReflectionsDelayLine[0].SetLength(0.089 * SampleRate);

  235.         earlyReflectionsDelayLine[0].SetIndex (0, 0.0199*SampleRate, 0.0219*SampleRate, 0.0354*SampleRate,0.0389*SampleRate, 0.0414*SampleRate, 0.0692*SampleRate, 0);

  236.         earlyReflectionsDelayLine[1].SetLength(0.069 * SampleRate);

  237.         earlyReflectionsDelayLine[1].SetIndex (0, 0.0099*SampleRate, 0.011*SampleRate, 0.0182*SampleRate,0.0189*SampleRate, 0.0213*SampleRate, 0.0431*SampleRate, 0);

  238.     }

  239. 

  240.     void setParameter(int index, T value){

  241.         switch(index){

  242.         case DAMPINGFREQ:

  243.             DampingFreq =  /* 1. - */ value; // FIXME?

  244.             break;

  245.         case DENSITY:

  246.             Density1 = value;

  247.             break;

  248.         case BANDWIDTHFREQ:

  249.             BandwidthFreq = value;

  250.             break;

  251.         case PREDELAY:

  252.             PreDelayTime = value;

  253.             break;

  254.         case SIZE:

  255.             Size = value;

  256.             allpassFourTap[0].Clear();

  257.             allpassFourTap[1].Clear();

  258.             allpassFourTap[2].Clear();

  259.             allpassFourTap[3].Clear();

  260.             allpassFourTap[0].SetLength(0.020 * SampleRate * Size);

  261.             allpassFourTap[1].SetLength(0.060 * SampleRate * Size);

  262.             allpassFourTap[2].SetLength(0.030 * SampleRate * Size);

  263.             allpassFourTap[3].SetLength(0.089 * SampleRate * Size);

  264.             allpassFourTap[1].SetIndex(0,0.006 * SampleRate * Size, 0.041 * SampleRate * Size, 0);

  265.             allpassFourTap[3].SetIndex(0,0.031 * SampleRate * Size, 0.011 * SampleRate * Size, 0);

  266.             staticDelayLine[0].Clear();

  267.             staticDelayLine[1].Clear();

  268.             staticDelayLine[2].Clear();

  269.             staticDelayLine[3].Clear();

  270.             staticDelayLine[0].SetLength(0.15 * SampleRate * Size);

  271.             staticDelayLine[1].SetLength(0.12 * SampleRate * Size);

  272.             staticDelayLine[2].SetLength(0.14 * SampleRate * Size);

  273.             staticDelayLine[3].SetLength(0.11 * SampleRate * Size);

  274.             staticDelayLine[0].SetIndex(0, 0.067 * SampleRate * Size, 0.011 * SampleRate * Size , 0.121 * SampleRate * Size);

  275.             staticDelayLine[1].SetIndex(0, 0.036 * SampleRate * Size, 0.089 * SampleRate * Size , 0);

  276.             staticDelayLine[2].SetIndex(0, 0.0089 * SampleRate * Size, 0.099 * SampleRate * Size , 0);

  277.             staticDelayLine[3].SetIndex(0, 0.067 * SampleRate * Size, 0.0041 * SampleRate * Size , 0);

  278.             break;

  279.         case DECAY:

  280.             Decay = value;

  281.             break;

  282.         case GAIN:

  283.             Gain = value;

  284.             break;

  285.         case MIX:

  286.             Mix = value;

  287.             break;

  288.         case EARLYMIX:

  289.             EarlyMix = value;

  290.             break;

  291.         }

  292.     }

  293. 

  294.     float getParameter(int index) const{

  295.         switch(index){

  296.         case DAMPINGFREQ:

  297.             return DampingFreq;

  298.             break;

  299.         case DENSITY:

  300.             return Density1;

  301.             break;

  302.         case BANDWIDTHFREQ:

  303.             return BandwidthFreq;

  304.             break;

  305.         case PREDELAY:

  306.             return PreDelayTime;

  307.             break;

  308.         case SIZE:

  309.             return Size;

  310.             break;

  311.         case DECAY:

  312.             return Decay;

  313.             break;

  314.         case GAIN:

  315.             return Gain;

  316.             break;

  317.         case MIX:

  318.             return Mix;

  319.             break;

  320.         case EARLYMIX:

  321.             return EarlyMix;

  322.             break;

  323.         default: return 0.f;

  324.             break;

  325. 

  326.         }

  327.     }

  328. 

  329.     void setSampleRate(T sr){

  330.         SampleRate = sr;

  331.         ControlRate = SampleRate / 1000;

  332.         reset();

  333.     }

  334. };

  335. 

  336. 

  337. 

  338. template<typename T, int maxLength>

  339. class Allpass

  340. {

  341. private:

  342.     T buffer[maxLength];

  343.     int index;

  344.     int Length;

  345.     T Feedback;

  346. 

  347. public:

  348.     Allpass()

  349.     {

  350.         SetLength ( maxLength - 1 );

  351.         Clear();

  352.         Feedback = 0.5;

  353.     }

  354. 

  355.     T operator()(T input)

  356.     {

  357.         T output;

  358.         T bufout;

  359.         bufout = buffer[index];

  360.         T temp = input * -Feedback;

  361.         output = bufout + temp;

  362.         buffer[index] = input + ((bufout+temp)*Feedback);

  363.         if(++index>=Length) index = 0;

  364.         return output;

  365.     }

  366. 

  367.     void SetLength (int Length)

  368.     {

  369.         if( Length >= maxLength )

  370.             Length = maxLength;

  371.         if( Length < 0 )

  372.             Length = 0;

  373. 

  374.         this->Length = Length;

  375.     }

  376. 

  377.     void SetFeedback(T feedback)

  378.     {

  379.         Feedback = feedback;

  380.     }

  381. 

  382.     void Clear()

  383.     {

  384.         std::memset(buffer, 0, sizeof(buffer));

  385.         index = 0;

  386.     }

  387. 

  388.     int GetLength() const

  389.     {

  390.         return Length;

  391.     }

  392. };

  393. 

  394. template<typename T, int maxLength>

  395. class StaticAllpassFourTap

  396. {

  397. private:

  398.     T buffer[maxLength];

  399.     int index1, index2, index3, index4;

  400.     int Length;

  401.     T Feedback;

  402. 

  403. public:

  404.     StaticAllpassFourTap()

  405.     {

  406.         SetLength ( maxLength - 1 );

  407.         Clear();

  408.         Feedback = 0.5;

  409.     }

  410. 

  411.     T operator()(T input)

  412.     {

  413.         T output;

  414.         T bufout;

  415. 

  416.         bufout = buffer[index1];

  417.         T temp = input * -Feedback;

  418.         output = bufout + temp;

  419.         buffer[index1] = input + ((bufout+temp)*Feedback);

  420. 

  421.         if(++index1>=Length)

  422.             index1 = 0;

  423.         if(++index2 >= Length)

  424.             index2 = 0;

  425.         if(++index3 >= Length)

  426.             index3 = 0;

  427.         if(++index4 >= Length)

  428.             index4 = 0;

  429. 

  430.         return output;

  431.     }

  432. 

  433.     void SetIndex (int Index1, int Index2, int Index3, int Index4)

  434.     {

  435.         index1 = Index1;

  436.         index2 = Index2;

  437.         index3 = Index3;

  438.         index4 = Index4;

  439.     }

  440. 

  441.     T GetIndex (int Index)

  442.     {

  443.         switch (Index)

  444.         {

  445.         case 0:

  446.             return buffer[index1];

  447.             break;

  448.         case 1:

  449.             return buffer[index2];

  450.             break;

  451.         case 2:

  452.             return buffer[index3];

  453.             break;

  454.         case 3:

  455.             return buffer[index4];

  456.             break;

  457.         default:

  458.             return buffer[index1];

  459.             break;

  460.         }

  461.     }

  462. 

  463.     void SetLength (int Length)

  464.     {

  465.         if( Length >= maxLength )

  466.             Length = maxLength;

  467.         if( Length < 0 )

  468.             Length = 0;

  469. 

  470.         this->Length = Length;

  471.     }

  472. 

  473. 

  474.     void Clear()

  475.     {

  476.         std::memset(buffer, 0, sizeof(buffer));

  477.         index1 = index2  = index3 = index4 = 0;

  478.     }

  479. 

  480.     void SetFeedback(T feedback)

  481.     {

  482.         Feedback = feedback;

  483.     }

  484. 

  485.     int GetLength() const

  486.     {

  487.         return Length;

  488.     }

  489. };

  490. 

  491. template<typename T, int maxLength>

  492. class StaticDelayLine

  493. {

  494. private:

  495.     T buffer[maxLength];

  496.     int index;

  497.     int Length;

  498.     T Feedback;

  499. 

  500. public:

  501.     StaticDelayLine()

  502.     {

  503.         SetLength ( maxLength - 1 );

  504.         Clear();

  505.     }

  506. 

  507.     T operator()(T input)

  508.     {

  509.         T output = buffer[index];

  510.         buffer[index++] = input;

  511.         if(index >= Length)

  512.             index = 0;

  513.         return output;

  514.     }

  515. 

  516.     void SetLength (int Length)

  517.     {

  518.         if( Length >= maxLength )

  519.             Length = maxLength;

  520.         if( Length < 0 )

  521.             Length = 0;

  522. 

  523.         this->Length = Length;

  524.     }

  525. 

  526.     void Clear()

  527.     {

  528.         std::memset(buffer, 0, sizeof(buffer));

  529.         index = 0;

  530.     }

  531. 

  532.     int GetLength() const

  533.     {

  534.         return Length;

  535.     }

  536. };

  537. 

  538. template<typename T, int maxLength>

  539. class StaticDelayLineFourTap

  540. {

  541. private:

  542.     T buffer[maxLength];

  543.     int index1, index2, index3, index4;

  544.     int Length;

  545.     T Feedback;

  546. 

  547. public:

  548.     StaticDelayLineFourTap()

  549.     {

  550.         SetLength ( maxLength - 1 );

  551.         Clear();

  552.     }

  553. 

  554.     //get ouput and iterate

  555.     T operator()(T input)

  556.     {

  557.         T output = buffer[index1];

  558.         buffer[index1++] = input;

  559.         if(index1 >= Length)

  560.             index1 = 0;

  561.         if(++index2 >= Length)

  562.             index2 = 0;

  563.         if(++index3 >= Length)

  564.             index3 = 0;

  565.         if(++index4 >= Length)

  566.             index4 = 0;

  567.         return output;

  568.     }

  569. 

  570.     void SetIndex (int Index1, int Index2, int Index3, int Index4)

  571.     {

  572.         index1 = Index1;

  573.         index2 = Index2;

  574.         index3 = Index3;

  575.         index4 = Index4;

  576.     }

  577. 

  578. 

  579.     T GetIndex (int Index)

  580.     {

  581.         switch (Index)

  582.         {

  583.         case 0:

  584.             return buffer[index1];

  585.             break;

  586.         case 1:

  587.             return buffer[index2];

  588.             break;

  589.         case 2:

  590.             return buffer[index3];

  591.             break;

  592.         case 3:

  593.             return buffer[index4];

  594.             break;

  595.         default:

  596.             return buffer[index1];

  597.             break;

  598.         }

  599.     }

  600. 

  601. 

  602.     void SetLength (int Length)

  603.     {

  604.         if( Length >= maxLength )

  605.             Length = maxLength;

  606.         if( Length < 0 )

  607.             Length = 0;

  608. 

  609.         this->Length = Length;

  610.     }

  611. 

  612. 

  613.     void Clear()

  614.     {

  615.         std::memset(buffer, 0, sizeof(buffer));

  616.         index1 = index2  = index3 = index4 = 0;

  617.     }

  618. 

  619. 

  620.     int GetLength() const

  621.     {

  622.         return Length;

  623.     }

  624. };

  625. 

  626. template<typename T, int maxLength>

  627. class StaticDelayLineEightTap

  628. {

  629. private:

  630.     T buffer[maxLength];

  631.     int index1, index2, index3, index4, index5, index6, index7, index8;

  632.     int Length;

  633.     T Feedback;

  634. 

  635. public:

  636.     StaticDelayLineEightTap()

  637.     {

  638.         SetLength ( maxLength - 1 );

  639.         Clear();

  640.     }

  641. 

  642.     //get ouput and iterate

  643.     T operator()(T input)

  644.     {

  645.         T output = buffer[index1];

  646.         buffer[index1++] = input;

  647.         if(index1 >= Length)

  648.             index1 = 0;

  649.         if(++index2 >= Length)

  650.             index2 = 0;

  651.         if(++index3 >= Length)

  652.             index3 = 0;

  653.         if(++index4 >= Length)

  654.             index4 = 0;

  655.         if(++index5 >= Length)

  656.             index5 = 0;

  657.         if(++index6 >= Length)

  658.             index6 = 0;

  659.         if(++index7 >= Length)

  660.             index7 = 0;

  661.         if(++index8 >= Length)

  662.             index8 = 0;

  663.         return output;

  664. 

  665.     }

  666. 

  667.     void SetIndex (int Index1, int Index2, int Index3, int Index4, int Index5, int Index6, int Index7, int Index8)

  668.     {

  669.         index1 = Index1;

  670.         index2 = Index2;

  671.         index3 = Index3;

  672.         index4 = Index4;

  673.         index5 = Index5;

  674.         index6 = Index6;

  675.         index7 = Index7;

  676.         index8 = Index8;

  677.     }

  678. 

  679. 

  680.     T GetIndex (int Index)

  681.     {

  682.         switch (Index)

  683.         {

  684.         case 0:

  685.             return buffer[index1];

  686.             break;

  687.         case 1:

  688.             return buffer[index2];

  689.             break;

  690.         case 2:

  691.             return buffer[index3];

  692.             break;

  693.         case 3:

  694.             return buffer[index4];

  695.             break;

  696.         case 4:

  697.             return buffer[index5];

  698.             break;

  699.         case 5:

  700.             return buffer[index6];

  701.             break;

  702.         case 6:

  703.             return buffer[index7];

  704.             break;

  705.         case 7:

  706.             return buffer[index8];

  707.             break;

  708.         default:

  709.             return buffer[index1];

  710.             break;

  711.         }

  712.     }

  713. 

  714.     void SetLength (int Length)

  715.     {

  716.         if( Length >= maxLength )

  717.             Length = maxLength;

  718.         if( Length < 0 )

  719.             Length = 0;

  720. 

  721.         this->Length = Length;

  722.     }

  723. 

  724. 

  725.     void Clear()

  726.     {

  727.         std::memset(buffer, 0, sizeof(buffer));

  728.         index1 = index2  = index3 = index4 = index5 = index6 = index7 = index8 = 0;

  729.     }

  730. 

  731. 

  732.     int GetLength() const

  733.     {

  734.         return Length;

  735.     }

  736. };

  737. 

  738. template<typename T, int OverSampleCount>

  739. class StateVariable

  740. {

  741. public:

  742. 

  743.     enum FilterType

  744.     {

  745.         LOWPASS,

  746.         HIGHPASS,

  747.         BANDPASS,

  748.         NOTCH,

  749.         FilterTypeCount

  750.     };

  751. 

  752. private:

  753. 

  754.     T sampleRate;

  755.     T frequency;

  756.     T q;

  757.     T f;

  758. 

  759.     T low;

  760.     T high;

  761.     T band;

  762.     T notch;

  763. 

  764.     T *out;

  765. 

  766. public:

  767.     StateVariable()

  768.     {

  769.         SetSampleRate(44100.);

  770.         Frequency(1000.);

  771.         Resonance(0);

  772.         Type(LOWPASS);

  773.         Reset();

  774.     }

  775. 

  776.     T operator()(T input)

  777.     {

  778.         for(unsigned int i = 0; i < OverSampleCount; i++)

  779.         {

  780.             low += f * band + 1e-25;

  781.             high = input - low - q * band;

  782.             band += f * high;

  783.             notch = low + high;

  784.         }

  785.         return *out;

  786.     }

  787. 

  788.     void Reset()

  789.     {

  790.         low = high = band = notch = 0;

  791.     }

  792. 

  793.     void SetSampleRate(T sampleRate)

  794.     {

  795.         this->sampleRate = sampleRate * OverSampleCount;

  796.         UpdateCoefficient();

  797.     }

  798. 

  799.     void Frequency(T frequency)

  800.     {

  801.         this->frequency = frequency;

  802.         UpdateCoefficient();

  803.     }

  804. 

  805.     void Resonance(T resonance)

  806.     {

  807.         this->q = 2 - 2 * resonance;

  808.     }

  809. 

  810.     void Type(int type)

  811.     {

  812.         switch(type)

  813.         {

  814.         case LOWPASS:

  815.             out = &low;

  816.             break;

  817. 

  818.         case HIGHPASS:

  819.             out = &high;

  820.             break;

  821. 

  822.         case BANDPASS:

  823.             out = &band;

  824.             break;

  825. 

  826.         case NOTCH:

  827.             out = &notch;

  828.             break;

  829. 

  830.         default:

  831.             out = &low;

  832.             break;

  833.         }

  834.     }

  835. 

  836. private:

  837.     void UpdateCoefficient()

  838.     {

  839.         f = 2. * std::sin(M_PI * frequency / sampleRate);

  840.     }

  841. };

  842. #endif