comparison src/vamp-hostsdk/PluginInputDomainAdapter.cpp @ 317:5cb298435765

Add support for changing window shape in PluginInputDomainAdapter

 */
 
 #include <vamp-hostsdk/PluginInputDomainAdapter.h>
 
 #include <cmath>
+
+#include "Window.h"
 
 
 /**
  * If you want to compile using FFTW instead of the built-in FFT
  * implementation for the PluginInputDomainAdapter, define HAVE_FFTW3

     void setProcessTimestampMethod(ProcessTimestampMethod m);
     ProcessTimestampMethod getProcessTimestampMethod() const;
     
     RealTime getTimestampAdjustment() const;
 
+    WindowType getWindowType() const;
+    void setWindowType(WindowType type);
+
 protected:
     Plugin *m_plugin;
     float m_inputSampleRate;
     int m_channels;
     int m_stepSize;
     int m_blockSize;
     float **m_freqbuf;
 
     double *m_ri;
-    double *m_window;
+
+    WindowType m_windowType;
+    Window<double> *m_window;
 
     ProcessTimestampMethod m_method;
     int m_processCount;
     float **m_shiftBuffers;
 

 
     FeatureSet processShiftingTimestamp(const float *const *inputBuffers, RealTime timestamp);
     FeatureSet processShiftingData(const float *const *inputBuffers, RealTime timestamp);
 
     size_t makeBlockSizeAcceptable(size_t) const;
+    
+    Window<double>::WindowType convertType(WindowType t) const;
 };
 
 PluginInputDomainAdapter::PluginInputDomainAdapter(Plugin *plugin) :
     PluginWrapper(plugin)
 {

 
 RealTime
 PluginInputDomainAdapter::getTimestampAdjustment() const
 {
     return m_impl->getTimestampAdjustment();
+}
+
+PluginInputDomainAdapter::WindowType
+PluginInputDomainAdapter::getWindowType() const
+{
+    return m_impl->getWindowType();
+}
+
+void
+PluginInputDomainAdapter::setWindowType(WindowType w)
+{
+    m_impl->setWindowType(w);
 }
 
 
 PluginInputDomainAdapter::Impl::Impl(Plugin *plugin, float inputSampleRate) :
     m_plugin(plugin),

     m_channels(0),
     m_stepSize(0),
     m_blockSize(0),
     m_freqbuf(0),
     m_ri(0),
+    m_windowType(HanningWindow),
     m_window(0),
     m_method(ShiftTimestamp),
     m_processCount(0),
     m_shiftBuffers(0),
 #ifdef HAVE_FFTW3

 #else
         delete[] m_ri;
         delete[] m_ro;
         delete[] m_io;
 #endif
-        delete[] m_window;
+
+        delete m_window;
     }
 }
 
 // for some visual studii apparently
 #ifndef M_PI

 #else
         delete[] m_ri;
         delete[] m_ro;
         delete[] m_io;
 #endif
-        delete[] m_window;
+        delete m_window;
     }
 
     m_stepSize = int(stepSize);
     m_blockSize = int(blockSize);
     m_channels = int(channels);
 
     m_freqbuf = new float *[m_channels];
     for (int c = 0; c < m_channels; ++c) {
         m_freqbuf[c] = new float[m_blockSize + 2];
     }
-    m_window = new double[m_blockSize];
-
-    for (int i = 0; i < m_blockSize; ++i) {
-        // Hanning window
-        m_window[i] = (0.50 - 0.50 * cos((2.0 * M_PI * i) / m_blockSize));
-    }
+
+    m_window = new Window<double>(convertType(m_windowType), m_blockSize);
 
 #ifdef HAVE_FFTW3
     m_ri = (double *)fftw_malloc(blockSize * sizeof(double));
     m_cbuf = (fftw_complex *)fftw_malloc((blockSize/2 + 1) * sizeof(fftw_complex));
     m_plan = fftw_plan_dft_r2c_1d(blockSize, m_ri, m_cbuf, FFTW_MEASURE);

 PluginInputDomainAdapter::Impl::getProcessTimestampMethod() const
 {
     return m_method;
 }
 
+void
+PluginInputDomainAdapter::Impl::setWindowType(WindowType t)
+{
+    if (m_windowType == t) return;
+    m_windowType = t;
+    if (m_window) {
+        delete m_window;
+        m_window = new Window<double>(convertType(m_windowType), m_blockSize);
+    }
+}
+
+PluginInputDomainAdapter::WindowType
+PluginInputDomainAdapter::Impl::getWindowType() const
+{
+    return m_windowType;
+}
+
+Window<double>::WindowType
+PluginInputDomainAdapter::Impl::convertType(WindowType t) const
+{
+    switch (t) {
+    case RectangularWindow:
+        return Window<double>::RectangularWindow;
+    case BartlettWindow:
+        return Window<double>::BartlettWindow;
+    case HammingWindow:
+        return Window<double>::HammingWindow;
+    case HanningWindow:
+        return Window<double>::HanningWindow;
+    case BlackmanWindow:
+        return Window<double>::BlackmanWindow;
+    case NuttallWindow:
+        return Window<double>::NuttallWindow;
+    case BlackmanHarrisWindow:
+        return Window<double>::BlackmanHarrisWindow;
+    }
+}
+
 Plugin::FeatureSet
 PluginInputDomainAdapter::Impl::process(const float *const *inputBuffers,
                                         RealTime timestamp)
 {
     if (m_plugin->getInputDomain() == TimeDomain) {

         timestamp = timestamp + getTimestampAdjustment();
     }
 
     for (int c = 0; c < m_channels; ++c) {
 
-        for (int i = 0; i < m_blockSize; ++i) {
-            m_ri[i] = double(inputBuffers[c][i]) * m_window[i];
-        }
+        m_window->cut(inputBuffers[c], m_ri);
 
         for (int i = 0; i < m_blockSize/2; ++i) {
             // FFT shift
             double value = m_ri[i];
             m_ri[i] = m_ri[i + m_blockSize/2];

         }
     }
 
     for (int c = 0; c < m_channels; ++c) {
 
-        for (int i = 0; i < m_blockSize; ++i) {
-            m_ri[i] = double(m_shiftBuffers[c][i]) * m_window[i];
-        }
+        m_window->cut(m_shiftBuffers[c], m_ri);
 
         for (int i = 0; i < m_blockSize/2; ++i) {
             // FFT shift
             double value = m_ri[i];
             m_ri[i] = m_ri[i + m_blockSize/2];