comparison devuvuzelator-vst.cpp @ 4:d90abfa9585a

* Adaptive method

 #include "public.sdk/source/vst2.x/audioeffect.h"
 
 #define snprintf _snprintf
 #define alloca _alloca
 
-#define FFTSIZE 1024
+#define FFTSIZE 4096
+#define WINSIZE 1024
+
+#include "median.h"
 
 class Devuvuzelator : public AudioEffect
 {
     enum {
-        LowParam       = 0,
-        HighParam      = 1,
-        FundamentalParam = 2,
-        BandwidthParam = 3,
-        HarmonicsParam = 4,
-        ReductionParam = 5,
-        NumParams      = 6
+        FundamentalParam = 1,
+        BandwidthParam = 2,
+        HarmonicsParam = 3,
+        ReductionParam = 4,
+        NumParams      = 5
     };
 
 public:
     Devuvuzelator(audioMasterCallback cb);
     ~Devuvuzelator();

     float m_bandwidth;
     int m_harmonics;
     float m_reduction;
 
     const int m_fftsize;
+    const int m_winsize;
     const int m_increment;
     int m_fill;
     int m_read;
     float *m_buffer;
     float *m_outacc;
     double *m_real;
     double *m_imag;
     double *m_window;
+    MedianFilter<double> **m_medians;
 };
 
 // VST params 0->1
 
 void
 Devuvuzelator::setParameter(VstInt32 index, float value)
 {
     switch (index) {
-    case 0: m_low = -80 + 80 * value; break;
-    case 1: m_high = -80 + 80 * value; break;
-    case 2: m_fundamental = 110 + 440 * value; break;
-    case 3: m_bandwidth = 20 + 80 * value; break;
-    case 4: m_harmonics = int(value * 6 + 0.5); break;
-    case 5: m_reduction = 20 * value; break;
+    case 0: m_fundamental = 50 + 720 * value; break;
+    case 1: m_bandwidth = 20 + 80 * value; break;
+    case 2: m_harmonics = int(value * 6 + 0.5); break;
+    case 3: m_reduction = 100 * value; break;
     }
 }
 
 float
 Devuvuzelator::getParameter(VstInt32 index)
 {
     switch (index) {
-    case 0: return (m_low + 80) / 80;
-    case 1: return (m_high + 80) / 80;
-    case 2: return (m_fundamental - 110) / 440;
-    case 3: return (m_bandwidth - 20) / 80;
-    case 4: return (m_harmonics / 6.f);
-    case 5: return m_reduction / 20;
-    }
-	return 0;
+    case 0: return (m_fundamental - 50) / 720;
+    case 1: return (m_bandwidth - 20) / 80;
+    case 2: return (m_harmonics / 6.f);
+    case 3: return m_reduction / 100;
+    }
+    return 0;
 }
 
 // NB! The max name length for VST parameter names, labels
 // (i.e. units) and display values (i.e. string renderings of current
 // value) is a rather amazing 8 bytes
 
 void
 Devuvuzelator::getParameterLabel(VstInt32 index, char *label)
 {
     const char *units[NumParams] = {
-        "dB",
-        "dB",
         "Hz",
         "Hz",
         "",
-        "dB",
+        "%",
     };
     
     vst_strncpy(label, units[index], kVstMaxParamStrLen);
 }
 
 void
 Devuvuzelator::getParameterDisplay(VstInt32 index, char *label)
 {
-	switch (index) {
-		case 0: snprintf(label, kVstMaxParamStrLen, "%f", m_low); break;
-		case 1: snprintf(label, kVstMaxParamStrLen, "%f", m_high); break;
-		case 2: snprintf(label, kVstMaxParamStrLen, "%f", m_fundamental); break;
-		case 3: snprintf(label, kVstMaxParamStrLen, "%f", m_bandwidth); break;
-		case 4: snprintf(label, kVstMaxParamStrLen, "%d", m_harmonics); break;
-		case 5: snprintf(label, kVstMaxParamStrLen, "%f", m_reduction); break;
-	}
+    switch (index) {
+    case 0: snprintf(label, kVstMaxParamStrLen, "%f", m_fundamental); break;
+    case 1: snprintf(label, kVstMaxParamStrLen, "%f", m_bandwidth); break;
+    case 2: snprintf(label, kVstMaxParamStrLen, "%d", m_harmonics); break;
+    case 3: snprintf(label, kVstMaxParamStrLen, "%f", m_reduction); break;
+    }
 }
 
 void
 Devuvuzelator::getParameterName(VstInt32 index, char *label)
 {
     const char *names[NumParams] = {
-        "Floor",
-        "Ceiling",
         "Pitch",
         "B/W",
         "Partials",
         "Reductn",
     };

 Devuvuzelator::Devuvuzelator(audioMasterCallback cb) :
     AudioEffect(cb, 0, NumParams),
     m_sampleRate(0),
     m_input(0),
     m_output(0),
-    m_low(0),
-    m_high(0),
     m_fftsize(FFTSIZE),
     m_increment(m_fftsize/4),
     m_fill(0),
     m_read(0)
 {
-    m_buffer = new float[m_fftsize];
-    m_outacc = new float[m_fftsize * 2];
+    m_buffer = new float[m_winsize];
+    m_outacc = new float[m_winsize * 2];
+    m_window = new double[m_winsize];
     m_real = new double[m_fftsize];
     m_imag = new double[m_fftsize];
-    m_window = new double[m_fftsize];
-
-    for (int i = 0; i < m_fftsize; ++i) {
-        m_window[i] = 0.5 - 0.5 * cos(2 * M_PI * i / m_fftsize);
-    }
-
-    m_low = -40;
-    m_high = -20;
-    m_fundamental = 220;
+    m_medians = new MedianFilter<double> *[m_fftsize/2+1];
+
+    for (int i = 0; i < m_winsize; ++i) {
+        m_window[i] = 0.5 - 0.5 * cos(2 * M_PI * i / m_winsize);
+    }
+    for (int i = 0; i < m_fftsize/2+1; ++i) {
+        m_medians[i] = 0;
+    }
+
+    m_fundamental = 230;
     m_bandwidth = 60;
     m_harmonics = 3;
-    m_reduction = 10;
+    m_reduction = 30;
     
     setUniqueID('qmvz');
     setNumInputs(1);
     setNumOutputs(1);
     canProcessReplacing(true);

     delete[] m_buffer;
     delete[] m_outacc;
     delete[] m_real;
     delete[] m_imag;
     delete[] m_window;
+    for (int i = 0; i < m_fftsize/2+1; ++i) {
+        delete m_medians[i];
+    }
+    delete[] m_medians;
 }
 
 void
 Devuvuzelator::reset()
 {
-    for (int i = 0; i < m_fftsize; ++i) {
+    for (int i = 0; i < m_winsize; ++i) {
         m_buffer[i] = 0.f;
     }
-    for (int i = 0; i < m_fftsize*2; ++i) {
+    for (int i = 0; i < m_winsize*2; ++i) {
         m_outacc[i] = 0.f;
     }
     m_fill = 0;
     m_read = 0;
+    for (int i = 0; i < m_fftsize/2+1; ++i) {
+        if (m_medians[i]) m_medians[i]->reset();
+    }
 }
 
 void
 Devuvuzelator::runImpl(unsigned long sampleCount)
 {
     if (!m_input || !m_output) return;
 
     int ii = 0;
     int oi = 0;
-	const int sc = sampleCount;
+    const int sc = sampleCount;
 
     while (ii < sc) {
 
-        m_output[oi++] = m_outacc[m_read++] / 1.5f;
-
-        if (m_fill == m_fftsize) {
+        m_output[oi++] = m_outacc[m_read++];
+
+        if (m_fill == m_winsize) {
 
             processFrame();
 
-            for (int j = m_increment; j < m_fftsize; ++j) {
+            for (int j = m_increment; j < m_winsize; ++j) {
                 m_buffer[j - m_increment] = m_buffer[j];
             }
 
-            for (int j = m_increment; j < m_fftsize*2; ++j) {
+            for (int j = m_increment; j < m_winsize*2; ++j) {
                 m_outacc[j - m_increment] = m_outacc[j];
             }
 
-            for (int j = m_fftsize*2 - m_increment; j < m_fftsize*2; ++j) {
+            for (int j = m_winsize*2 - m_increment; j < m_winsize*2; ++j) {
                 m_outacc[j] = 0.f;
             }
 
             m_fill -= m_increment;
             m_read -= m_increment;

 
 void
 Devuvuzelator::processFrame()
 {
     double *frame = (double *)alloca(m_fftsize * sizeof(double));
-    int ix = m_fftsize/2;
     for (int i = 0; i < m_fftsize; ++i) {
-        frame[ix++] = m_buffer[i] * m_window[i];
+        frame[i] = 0.0;
+    }
+
+    int ix = m_fftsize - m_winsize/2;
+    while (ix < 0) ix += m_fftsize;
+    for (int i = 0; i < m_winsize; ++i) {
+        frame[ix++] += m_buffer[i] * m_window[i];
         if (ix == m_fftsize) ix = 0;
     }
 
     fft(m_fftsize, false, frame, 0, m_real, m_imag);
 

     }
 
     double *spare = (double *)alloca(m_fftsize * sizeof(double));
     fft(m_fftsize, true, m_real, m_imag, frame, spare);
 
-    ix = m_fftsize/2;
-    for (int i = 0; i < m_fftsize; ++i) {
-        m_outacc[m_fftsize + i] += frame[ix++] * m_window[i];
+    ix = m_fftsize - m_winsize/2;
+    while (ix < 0) ix += m_fftsize;
+    for (int i = 0; i < m_winsize; ++i) {
+        m_outacc[m_winsize + i] += frame[ix++];
         if (ix == m_fftsize) ix = 0;
     }
 }
 
 // FFT implementation by Don Cross, public domain.