Merge branch 'master-upstream'

Conflicts:
	src/Effects/Echo.cpp
	src/Misc/Util.cpp

AUTHORS.txt

@@ -25,4 +25,6 @@ Contributors:
         Jonathan Liles (NSM & NTK support)
         Johannes Lorenz (Effect Documentation)
         Ilario Glasgo (Italian Doc Translation)
+        Christopher Oliver (Unison Regrssion Fix, presets fix)
+        Filipe Coelho (Globals Cleanup)
 

src/DSP/AnalogFilter.cpp

@@ -32,8 +32,10 @@
 AnalogFilter::AnalogFilter(unsigned char Ftype,
                            float Ffreq,
                            float Fq,
-                           unsigned char Fstages)
-    :type(Ftype),
+                           unsigned char Fstages,
+                           unsigned int srate, int bufsize)
+    :Filter(srate, bufsize),
+      type(Ftype),
       stages(Fstages),
       freq(Ffreq),
       q(Fq),
@@ -75,8 +77,8 @@ void AnalogFilter::computefiltercoefs(void)
 
     //do not allow frequencies bigger than samplerate/2
     float freq = this->freq;
-    if(freq > (synth->halfsamplerate_f - 500.0f)) {
-        freq      = synth->halfsamplerate_f - 500.0f;
+    if(freq > (halfsamplerate_f - 500.0f)) {
+        freq      = halfsamplerate_f - 500.0f;
         zerocoefs = true;
     }
     if(freq < 0.1f)
@@ -99,7 +101,7 @@ void AnalogFilter::computefiltercoefs(void)
     float *d = coeff.d;
 
     //General Constants
-    const float omega = 2 * PI * freq / synth->samplerate_f;
+    const float omega = 2 * PI * freq / samplerate_f;
     const float sn    = sinf(omega), cs = cosf(omega);
     float       alpha, beta;
 
@@ -110,7 +112,7 @@ void AnalogFilter::computefiltercoefs(void)
     switch(type) {
         case 0: //LPF 1 pole
             if(!zerocoefs)
-                tmp = expf(-2.0f * PI * freq / synth->samplerate_f);
+                tmp = expf(-2.0f * PI * freq / samplerate_f);
             else
                 tmp = 0.0f;
             c[0]  = 1.0f - tmp;
@@ -122,7 +124,7 @@ void AnalogFilter::computefiltercoefs(void)
             break;
         case 1: //HPF 1 pole
             if(!zerocoefs)
-                tmp = expf(-2.0f * PI * freq / synth->samplerate_f);
+                tmp = expf(-2.0f * PI * freq / samplerate_f);
             else
                 tmp = 0.0f;
             c[0]  = (1.0f + tmp) / 2.0f;
@@ -277,7 +279,7 @@ void AnalogFilter::setfreq(float frequency)
         rap = 1.0f / rap;
 
     oldabovenq = abovenq;
-    abovenq    = frequency > (synth->halfsamplerate_f - 500.0f);
+    abovenq    = frequency > (halfsamplerate_f - 500.0f);
 
     bool nyquistthresh = (abovenq ^ oldabovenq);
 
@@ -353,9 +355,9 @@ inline void AnalogBiquadFilterB(const float coeff[5], float &src, float work[4])
 void AnalogFilter::singlefilterout(float *smp, fstage &hist,
                                    const Coeff &coeff)
 {
-    assert((synth->buffersize % 8) == 0);
+    assert((buffersize % 8) == 0);
     if(order == 1) {  //First order filter
-        for(int i = 0; i < synth->buffersize; ++i) {
+        for(int i = 0; i < buffersize; ++i) {
             float y0 = smp[i] * coeff.c[0] + hist.x1 * coeff.c[1]
                        + hist.y1 * coeff.d[1];
             hist.y1 = y0;
@@ -365,7 +367,7 @@ void AnalogFilter::singlefilterout(float *smp, fstage &hist,
     } else if(order == 2) {//Second order filter
         const float coeff_[5] = {coeff.c[0], coeff.c[1], coeff.c[2],  coeff.d[1], coeff.d[2]};
         float work[4]  = {hist.x1, hist.x2, hist.y1, hist.y2};
-        for(int i = 0; i < synth->buffersize; i+=8) {
+        for(int i = 0; i < buffersize; i+=8) {
             AnalogBiquadFilterA(coeff_, smp[i + 0], work);
             AnalogBiquadFilterB(coeff_, smp[i + 1], work);
             AnalogBiquadFilterA(coeff_, smp[i + 2], work);
@@ -389,27 +391,26 @@ void AnalogFilter::filterout(float *smp)
 
     if(needsinterpolation) {
         //Merge Filter at old coeff with new coeff
-        float *ismp = getTmpBuffer();
-        memcpy(ismp, smp, synth->bufferbytes);
+        float ismp[buffersize];
+        memcpy(ismp, smp, bufferbytes);
 
         for(int i = 0; i < stages + 1; ++i)
             singlefilterout(ismp, oldHistory[i], oldCoeff);
 
-        for(int i = 0; i < synth->buffersize; ++i) {
-            float x = (float)i / synth->buffersize_f;
+        for(int i = 0; i < buffersize; ++i) {
+            float x = (float)i / buffersize_f;
             smp[i] = ismp[i] * (1.0f - x) + smp[i] * x;
         }
-        returnTmpBuffer(ismp);
         needsinterpolation = false;
     }
 
-    for(int i = 0; i < synth->buffersize; ++i)
+    for(int i = 0; i < buffersize; ++i)
         smp[i] *= outgain;
 }
 
 float AnalogFilter::H(float freq)
 {
-    float fr = freq / synth->samplerate_f * PI * 2.0f;
+    float fr = freq / samplerate_f * PI * 2.0f;
     float x  = coeff.c[0], y = 0.0f;
     for(int n = 1; n < 3; ++n) {
         x += cosf(n * fr) * coeff.c[n];

src/DSP/AnalogFilter.h

@@ -35,7 +35,7 @@ class AnalogFilter:public Filter
 {
     public:
         AnalogFilter(unsigned char Ftype, float Ffreq, float Fq,
-                     unsigned char Fstages);
+                     unsigned char Fstages, unsigned int srate, int bufsize);
         ~AnalogFilter();
         void filterout(float *smp);
         void setfreq(float frequency);

src/DSP/Filter.cpp

@@ -29,24 +29,37 @@
 #include "SVFilter.h"
 #include "../Params/FilterParams.h"
 
-Filter *Filter::generate(FilterParams *pars)
+Filter::Filter(unsigned int srate, int bufsize)
+    : outgain(1.0f),
+      samplerate(srate),
+      buffersize(bufsize)
 {
+    alias();
+}
+
+Filter *Filter::generate(FilterParams *pars, unsigned int srate, int bufsize)
+{
+    if (srate == 0)
+        srate = synth->samplerate;
+    if (bufsize == 0)
+        bufsize = synth->buffersize;
+
     unsigned char Ftype   = pars->Ptype;
     unsigned char Fstages = pars->Pstages;
 
     Filter *filter;
     switch(pars->Pcategory) {
         case 1:
-            filter = new FormantFilter(pars);
+            filter = new FormantFilter(pars, srate, bufsize);
             break;
         case 2:
-            filter = new SVFilter(Ftype, 1000.0f, pars->getq(), Fstages);
+            filter = new SVFilter(Ftype, 1000.0f, pars->getq(), Fstages, srate, bufsize);
             filter->outgain = dB2rap(pars->getgain());
             if(filter->outgain > 1.0f)
                 filter->outgain = sqrt(filter->outgain);
             break;
         default:
-            filter = new AnalogFilter(Ftype, 1000.0f, pars->getq(), Fstages);
+            filter = new AnalogFilter(Ftype, 1000.0f, pars->getq(), Fstages, srate, bufsize);
             if((Ftype >= 6) && (Ftype <= 8))
                 filter->setgain(pars->getgain());
             else

src/DSP/Filter.h

@@ -29,8 +29,9 @@ class Filter
 {
     public:
         static float getrealfreq(float freqpitch);
-        static Filter *generate(class FilterParams * pars);
+        static Filter *generate(class FilterParams * pars, unsigned int srate = 0, int bufsize = 0);
 
+        Filter(unsigned int srate, int bufsize);
         virtual ~Filter() {}
         virtual void filterout(float *smp)    = 0;
         virtual void setfreq(float frequency) = 0;
@@ -40,6 +41,24 @@ class Filter
 
     protected:
         float outgain;
+
+        // current setup
+        unsigned int samplerate;
+        int buffersize;
+
+        // alias for above terms
+        float samplerate_f;
+        float halfsamplerate_f;
+        float buffersize_f;
+        int   bufferbytes;
+
+        inline void alias()
+        {
+            samplerate_f     = samplerate;
+            halfsamplerate_f = samplerate_f / 2.0f;
+            buffersize_f     = buffersize;
+            bufferbytes      = buffersize * sizeof(float);
+        }
 };
 
 #endif

src/DSP/FormantFilter.cpp

@@ -27,11 +27,12 @@
 #include "AnalogFilter.h"
 #include "../Params/FilterParams.h"
 
-FormantFilter::FormantFilter(FilterParams *pars)
+FormantFilter::FormantFilter(FilterParams *pars, unsigned int srate, int bufsize)
+    : Filter(srate, bufsize)
 {
     numformants = pars->Pnumformants;
     for(int i = 0; i < numformants; ++i)
-        formant[i] = new AnalogFilter(4 /*BPF*/, 1000.0f, 10.0f, pars->Pstages);
+        formant[i] = new AnalogFilter(4 /*BPF*/, 1000.0f, 10.0f, pars->Pstages, srate, bufsize);
     cleanup();
 
     for(int j = 0; j < FF_MAX_VOWELS; ++j)
@@ -203,29 +204,27 @@ void FormantFilter::setfreq_and_q(float frequency, float q_)
 
 void FormantFilter::filterout(float *smp)
 {
-    float *inbuffer = getTmpBuffer();
+    float inbuffer[buffersize];
 
-    memcpy(inbuffer, smp, synth->bufferbytes);
-    memset(smp, 0, synth->bufferbytes);
+    memcpy(inbuffer, smp, bufferbytes);
+    memset(smp, 0, bufferbytes);
 
     for(int j = 0; j < numformants; ++j) {
-        float *tmpbuf = getTmpBuffer();
-        for(int i = 0; i < synth->buffersize; ++i)
+        float tmpbuf[buffersize];
+        for(int i = 0; i < buffersize; ++i)
             tmpbuf[i] = inbuffer[i] * outgain;
         formant[j]->filterout(tmpbuf);
 
         if(ABOVE_AMPLITUDE_THRESHOLD(oldformantamp[j], currentformants[j].amp))
-            for(int i = 0; i < synth->buffersize; ++i)
+            for(int i = 0; i < buffersize; ++i)
                 smp[i] += tmpbuf[i]
                           * INTERPOLATE_AMPLITUDE(oldformantamp[j],
                                                   currentformants[j].amp,
                                                   i,
-                                                  synth->buffersize);
+                                                  buffersize);
         else
-            for(int i = 0; i < synth->buffersize; ++i)
+            for(int i = 0; i < buffersize; ++i)
                 smp[i] += tmpbuf[i] * currentformants[j].amp;
-        returnTmpBuffer(tmpbuf);
         oldformantamp[j] = currentformants[j].amp;
     }
-    returnTmpBuffer(inbuffer);
 }

src/DSP/FormantFilter.h

@@ -30,7 +30,7 @@
 class FormantFilter:public Filter
 {
     public:
-        FormantFilter(class FilterParams *pars);
+        FormantFilter(class FilterParams *pars, unsigned int srate, int bufsize);
         ~FormantFilter();
         void filterout(float *smp);
         void setfreq(float frequency);

src/DSP/SVFilter.cpp

@@ -31,8 +31,9 @@
 #include "SVFilter.h"
 
 SVFilter::SVFilter(unsigned char Ftype, float Ffreq, float Fq,
-                   unsigned char Fstages)
-    :type(Ftype),
+                   unsigned char Fstages, unsigned int srate, int bufsize)
+    :Filter(srate, bufsize),
+      type(Ftype),
       stages(Fstages),
       freq(Ffreq),
       q(Fq),
@@ -60,7 +61,7 @@ void SVFilter::cleanup()
 
 void SVFilter::computefiltercoefs(void)
 {
-    par.f = freq / synth->samplerate_f * 4.0f;
+    par.f = freq / samplerate_f * 4.0f;
     if(par.f > 0.99999f)
         par.f = 0.99999f;
     par.q      = 1.0f - atanf(sqrtf(q)) * 2.0f / PI;
@@ -78,7 +79,7 @@ void SVFilter::setfreq(float frequency)
         rap = 1.0f / rap;
 
     oldabovenq = abovenq;
-    abovenq    = frequency > (synth->samplerate_f / 2 - 500.0f);
+    abovenq    = frequency > (samplerate_f / 2 - 500.0f);
 
     bool nyquistthresh = (abovenq ^ oldabovenq);
 
@@ -149,7 +150,7 @@ void SVFilter::singlefilterout(float *smp, fstage &x, parameters &par)
 			break;
     }
 
-    for(int i = 0; i < synth->buffersize; ++i) {
+    for(int i = 0; i < buffersize; ++i) {
         x.low   = x.low + par.f * x.band;
         x.high  = par.q_sqrt * smp[i] - x.low - par.q * x.band;
         x.band  = par.f * x.high + x.band;
@@ -164,20 +165,19 @@ void SVFilter::filterout(float *smp)
         singlefilterout(smp, st[i], par);
 
     if(needsinterpolation) {
-        float *ismp = getTmpBuffer();
-        memcpy(ismp, smp, synth->bufferbytes);
+        float ismp[buffersize];
+        memcpy(ismp, smp, bufferbytes);
 
         for(int i = 0; i < stages + 1; ++i)
             singlefilterout(ismp, st[i], ipar);
 
-        for(int i = 0; i < synth->buffersize; ++i) {
-            float x = i / synth->buffersize_f;
+        for(int i = 0; i < buffersize; ++i) {
+            float x = i / buffersize_f;
             smp[i] = ismp[i] * (1.0f - x) + smp[i] * x;
         }
-        returnTmpBuffer(ismp);
         needsinterpolation = false;
     }
 
-    for(int i = 0; i < synth->buffersize; ++i)
+    for(int i = 0; i < buffersize; ++i)
         smp[i] *= outgain;
 }

src/DSP/SVFilter.h

@@ -32,7 +32,8 @@ class SVFilter:public Filter
         SVFilter(unsigned char Ftype,
                  float Ffreq,
                  float Fq,
-                 unsigned char Fstages);
+                 unsigned char Fstages,
+                 unsigned int srate, int bufsize);
         ~SVFilter();
         void filterout(float *smp);
         void setfreq(float frequency);

src/DSP/Unison.cpp

@@ -27,18 +27,19 @@
 
 #include "Unison.h"
 
-Unison::Unison(int update_period_samples_, float max_delay_sec_)
+Unison::Unison(int update_period_samples_, float max_delay_sec_, float srate_f)
     :unison_size(0),
       base_freq(1.0f),
       uv(NULL),
       update_period_samples(update_period_samples_),
       update_period_sample_k(0),
-      max_delay((int)(synth->samplerate_f * max_delay_sec_) + 1),
+      max_delay((int)(srate_f * max_delay_sec_) + 1),
       delay_k(0),
       first_time(false),
       delay_buffer(NULL),
       unison_amplitude_samples(0.0f),
-      unison_bandwidth_cents(10.0f)
+      unison_bandwidth_cents(10.0f),
+      samplerate_f(srate_f)
 {
     if(max_delay < 10)
         max_delay = 10;
@@ -89,23 +90,23 @@ void Unison::updateParameters(void)
 {
     if(!uv)
         return;
-    float increments_per_second = synth->samplerate_f
+    float increments_per_second = samplerate_f
                                   / (float) update_period_samples;
 //	printf("#%g, %g\n",increments_per_second,base_freq);
     for(int i = 0; i < unison_size; ++i) {
-        float base = powf(UNISON_FREQ_SPAN, synth->numRandom() * 2.0f - 1.0f);
+        float base = powf(UNISON_FREQ_SPAN, SYNTH_T::numRandom() * 2.0f - 1.0f);
         uv[i].relative_amplitude = base;
         float period = base / base_freq;
         float m      = 4.0f / (period * increments_per_second);
-        if(synth->numRandom() < 0.5f)
+        if(SYNTH_T::numRandom() < 0.5f)
             m = -m;
         uv[i].step = m;
 //		printf("%g %g\n",uv[i].relative_amplitude,period);
     }
 
     float max_speed = powf(2.0f, unison_bandwidth_cents / 1200.0f);
     unison_amplitude_samples = 0.125f * (max_speed - 1.0f)
-                               * synth->samplerate_f / base_freq;
+                               * samplerate_f / base_freq;
 
     //If functions exceed this limit, they should have requested a bigguer delay
     //and thus are buggy