comparison plugins/AdaptiveSpectrogram.cpp @ 156:93355d263f8e

Add decimation factor to adaptive spectrogram

 #include <cfloat>
 
 #include <iostream>
 
 #include <dsp/transforms/FFT.h>
+#include <dsp/rateconversion/Decimator.h>
 
 using std::string;
 using std::vector;
 using std::cerr;
 using std::endl;

     Plugin(inputSampleRate),
     m_w(8),
     m_n(2),
     m_coarse(false),
     m_threaded(true),
-    m_threadsInUse(false)
+    m_threadsInUse(false),
+    m_decFactor(1),
+    m_buflen(0),
+    m_buffer(0),
+    m_decimator(0)
 {
 }
 
 AdaptiveSpectrogram::~AdaptiveSpectrogram()
 {

     for (FFTMap::iterator i = m_fftThreads.begin();
          i != m_fftThreads.end(); ++i) {
         delete i->second;
     }
     m_fftThreads.clear();
+
+    delete[] m_buffer;
+    delete m_decimator;
 }
 
 string
 AdaptiveSpectrogram::getIdentifier() const
 {

 }
 
 int
 AdaptiveSpectrogram::getPluginVersion() const
 {
-    return 1;
+    return 2;
 }
 
 string
 AdaptiveSpectrogram::getCopyright() const
 {

 }
 
 size_t
 AdaptiveSpectrogram::getPreferredStepSize() const
 {
-    return ((2 << m_w) << m_n) / 2;
+    return getPreferredBlockSize();
 }
 
 size_t
 AdaptiveSpectrogram::getPreferredBlockSize() const
 {
-    return (2 << m_w) << m_n;
+    // the /2 at the end is for 50% overlap (we handle framing ourselves)
+    return ((2 << m_w) << m_n) * m_decFactor / 2;
 }
 
 bool
 AdaptiveSpectrogram::initialise(size_t channels, size_t stepSize, size_t blockSize)
 {
     if (channels < getMinChannelCount() ||
 	channels > getMaxChannelCount()) return false;
 
+    if (blockSize != getPreferredBlockSize()) {
+        std::cerr << "AdaptiveSpectrogram::initialise: Block size " << blockSize << " does not match required block size of " << getPreferredBlockSize() << std::endl;
+        return false;
+    }
+    if (stepSize != getPreferredStepSize()) {
+        std::cerr << "AdaptiveSpectrogram::initialise: Step size " << stepSize << " does not match required step size of " << getPreferredStepSize() << std::endl;
+        return false;
+    }
+
+    if (m_decFactor > 1) {
+        m_decimator = new Decimator(blockSize, m_decFactor);
+    }
+
+    m_buflen = (blockSize * 2) / m_decFactor; // *2 for 50% overlap
+    m_buffer = new float[m_buflen];
+
+    reset();
+    
     return true;
 }
 
 void
 AdaptiveSpectrogram::reset()
 {
-
+    if (m_decimator) m_decimator->resetFilter();
+    for (int i = 0; i < m_buflen; ++i) m_buffer[i] = 0.f;
 }
 
 AdaptiveSpectrogram::ParameterList
 AdaptiveSpectrogram::getParameterDescriptors() const
 {

     desc2.valueNames.push_back("4096");
     desc2.valueNames.push_back("8192");
     desc2.valueNames.push_back("16384");
     list.push_back(desc2);
 
+    desc2.identifier = "dec";
+    desc2.name = "Decimation factor";
+    desc2.description = "Factor to down-sample by, increasing speed but lowering maximum frequency";
+    desc2.unit = "";
+    desc2.minValue = 0;
+    desc2.maxValue = 3;
+    desc2.defaultValue = 0;
+    desc2.isQuantized = true;
+    desc2.quantizeStep = 1;
+    desc2.valueNames.clear();
+    desc2.valueNames.push_back("No decimation");
+    desc2.valueNames.push_back("2");
+    desc2.valueNames.push_back("4");
+    desc2.valueNames.push_back("8");
+    list.push_back(desc2);
+
     ParameterDescriptor desc3;
     desc3.identifier = "coarse";
     desc3.name = "Omit alternate resolutions";
     desc3.description = "Generate a coarser spectrogram faster by excluding every alternate resolution (first and last resolution are always retained)";
     desc3.unit = "";

 {
     if (id == "n") return m_n+1;
     else if (id == "w") return m_w+1;
     else if (id == "threaded") return (m_threaded ? 1 : 0);
     else if (id == "coarse") return (m_coarse ? 1 : 0);
+    else if (id == "dec") {
+        int f = m_decFactor;
+        int p = 0;
+        while (f > 1) {
+            f >>= 1;
+            p += 1;
+        }
+        return p;
+    }
     return 0.f;
 }
 
 void
 AdaptiveSpectrogram::setParameter(std::string id, float value)

         if (w >= 1 && w <= 14) m_w = w-1;
     } else if (id == "threaded") {
         m_threaded = (value > 0.5);
     } else if (id == "coarse") {
         m_coarse = (value > 0.5);
+    } else if (id == "dec") {
+        int p = lrintf(value);
+        if (p >= 0 && p <= 3) m_decFactor = 1 << p;
     }
 }
 
 AdaptiveSpectrogram::OutputList
 AdaptiveSpectrogram::getOutputDescriptors() const

     d.identifier = "output";
     d.name = "Output";
     d.description = "The output of the plugin";
     d.unit = "";
     d.hasFixedBinCount = true;
-    d.binCount = getPreferredBlockSize() / 2;
+    d.binCount = getPreferredBlockSize() / (m_decFactor * 2);
     d.hasKnownExtents = false;
     d.isQuantized = false;
     d.sampleType = OutputDescriptor::FixedSampleRate;
-    d.sampleRate = m_inputSampleRate / ((2 << m_w) / 2);
+    d.sampleRate = m_inputSampleRate / (m_decFactor * ((2 << m_w) / 2));
     d.hasDuration = false;
     char name[20];
     for (int i = 0; i < d.binCount; ++i) {
-        float freq = (m_inputSampleRate / (d.binCount * 2)) * (i + 1); // no DC bin
+        float freq = (m_inputSampleRate / (m_decFactor * (d.binCount * 2)) * (i + 1)); // no DC bin
         sprintf(name, "%d Hz", int(freq));
         d.binNames.push_back(name);
     }
     list.push_back(d);
 

 }
 
 AdaptiveSpectrogram::FeatureSet
 AdaptiveSpectrogram::process(const float *const *inputBuffers, RealTime ts)
 {
+    // framing: shift and write the new data to right half
+    for (int i = 0; i < m_buflen/2; ++i) {
+        m_buffer[i] = m_buffer[m_buflen/2 + i];
+    }
+
+    if (m_decFactor == 1) {
+        for (int i = 0; i < m_buflen/2; ++i) {
+            m_buffer[m_buflen/2 + i] = inputBuffers[0][i];
+        }
+    } else {
+        m_decimator->process(inputBuffers[0], m_buffer + m_buflen/2);
+    }
+
     FeatureSet fs;
 
     int minwid = (2 << m_w), maxwid = ((2 << m_w) << m_n);
 
 #ifdef DEBUG_VERBOSE

 
         if (m_fftThreads.find(w) == m_fftThreads.end()) {
             m_fftThreads[w] = new FFTThread(w);
         }
         if (m_threaded) {
-            m_fftThreads[w]->startCalculation
-                (inputBuffers[0], s, index, maxwid);
+            m_fftThreads[w]->startCalculation(m_buffer, s, index, maxwid);
         } else {
-            m_fftThreads[w]->setParameters
-                (inputBuffers[0], s, index, maxwid);
+            m_fftThreads[w]->setParameters(m_buffer, s, index, maxwid);
             m_fftThreads[w]->performTask();
         }
         w *= 2;
         ++index;
     }