comparison layer/SpectrogramLayer.cpp @ 109:12340cb6e6cb

* Add FFT data server class to provide a file cache mapping for each
  required set of FFT parameters and source model. Make use of it in
  feature extraction plugin transform, though not in other places yet.

* Add zero-pad option to spectrogram layer and remove window shape option
  from the property box.  To be revised.

 
 #include <cassert>
 #include <cmath>
 
 //#define DEBUG_SPECTROGRAM_REPAINT 1
-
-static double mod(double x, double y)
-{
-    double a = floor(x / y);
-    double b = x - (y * a);
-    return b;
-}
-
-static float modf(float x, float y)
-{
-    float a = floorf(x / y);
-    float b = x - (y * a);
-    return b;
-}
-
-static double princarg(double ang)
-{
-    return mod(ang + M_PI, -2 * M_PI) + M_PI;
-}
-
-static float princargf(float ang)
-{
-    return modf(ang + M_PI, -2 * M_PI) + M_PI;
-}
-
 
 SpectrogramLayer::SpectrogramLayer(Configuration config) :
     Layer(),
     m_model(0),
     m_channel(0),
     m_windowSize(1024),
     m_windowType(HanningWindow),
     m_windowHopLevel(2),
+    m_zeroPadLevel(0),
     m_fftSize(1024),
     m_gain(1.0),
     m_threshold(0.0),
     m_colourRotation(0),
     m_minFrequency(0),

     m_exiting(false)
 {
     if (config == MelodicRange) {
 	setWindowSize(8192);
 	setWindowHopLevel(4);
-	setWindowType(ParzenWindow);
+//	setWindowType(ParzenWindow);
 	setMaxFrequency(1000);
 	setColourScale(LinearColourScale);
     } else if (config == MelodicPeaks) {
 	setWindowSize(4096);
 	setWindowHopLevel(5);
-	setWindowType(BlackmanWindow);
+//	setWindowType(BlackmanWindow);
 	setMaxFrequency(2000);
 	setMinFrequency(40);
 	setFrequencyScale(LogFrequencyScale);
 	setColourScale(MeterColourScale);
 	setBinDisplay(PeakFrequencies);

 SpectrogramLayer::getProperties() const
 {
     PropertyList list;
     list.push_back("Colour");
     list.push_back("Colour Scale");
-    list.push_back("Window Type");
+//    list.push_back("Window Type");
     list.push_back("Window Size");
     list.push_back("Window Increment");
     list.push_back("Normalize Columns");
     list.push_back("Bin Display");
     list.push_back("Threshold");
     list.push_back("Gain");
     list.push_back("Colour Rotation");
     list.push_back("Min Frequency");
     list.push_back("Max Frequency");
     list.push_back("Frequency Scale");
+    list.push_back("Zero Padding");
     return list;
 }
 
 QString
 SpectrogramLayer::getPropertyLabel(const PropertyName &name) const

     if (name == "Gain") return tr("Gain");
     if (name == "Colour Rotation") return tr("Colour Rotation");
     if (name == "Min Frequency") return tr("Min Frequency");
     if (name == "Max Frequency") return tr("Max Frequency");
     if (name == "Frequency Scale") return tr("Frequency Scale");
+    if (name == "Zero Padding") return tr("Smoothing");
     return "";
 }
 
 Layer::PropertyType
 SpectrogramLayer::getPropertyType(const PropertyName &name) const
 {
     if (name == "Gain") return RangeProperty;
     if (name == "Colour Rotation") return RangeProperty;
     if (name == "Normalize Columns") return ToggleProperty;
     if (name == "Threshold") return RangeProperty;
+    if (name == "Zero Padding") return ToggleProperty;
     return ValueProperty;
 }
 
 QString
 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Window Size" ||
 	name == "Window Type" ||
-	name == "Window Increment") return tr("Window");
+	name == "Window Increment" ||
+        name == "Zero Padding") return tr("Window");
     if (name == "Colour" ||
 	name == "Gain" ||
 	name == "Threshold" ||
 	name == "Colour Rotation") return tr("Colour");
     if (name == "Normalize Columns" ||

 	*min = 0;
 	*max = 5;
 	
         deft = m_windowHopLevel;
     
+    } else if (name == "Zero Padding") {
+	
+	*min = 0;
+	*max = 1;
+	
+        deft = m_zeroPadLevel > 0 ? 1 : 0;
+    
     } else if (name == "Min Frequency") {
 
 	*min = 0;
 	*max = 9;
 

 	case 2: return tr("1/2");
 	case 3: return tr("1/4");
 	case 4: return tr("1/8");
 	case 5: return tr("1/16");
 	}
+    }
+    if (name == "Zero Padding") {
+        if (value == 0) return tr("None");
+        return QString("%1x").arg(value + 1);
     }
     if (name == "Min Frequency") {
 	switch (value) {
 	default:
 	case 0: return tr("No min");

 	setWindowType(WindowType(value));
     } else if (name == "Window Size") {
 	setWindowSize(32 << value);
     } else if (name == "Window Increment") {
         setWindowHopLevel(value);
+    } else if (name == "Zero Padding") {
+        setZeroPadLevel(value > 0.1 ? 3 : 0);
     } else if (name == "Min Frequency") {
 	switch (value) {
 	default:
 	case 0: setMinFrequency(0); break;
 	case 1: setMinFrequency(10); break;

     m_mutex.lock();
     m_cacheInvalid = true;
     invalidatePixmapCaches();
     
     m_windowSize = ws;
-    m_fftSize = ws;
+    m_fftSize = ws * (m_zeroPadLevel + 1);
     
     m_mutex.unlock();
 
     emit layerParametersChanged();
 

 
 size_t
 SpectrogramLayer::getWindowHopLevel() const
 {
     return m_windowHopLevel;
+}
+
+void
+SpectrogramLayer::setZeroPadLevel(size_t v)
+{
+    if (m_zeroPadLevel == v) return;
+
+    m_mutex.lock();
+    m_cacheInvalid = true;
+    invalidatePixmapCaches();
+    
+    m_zeroPadLevel = v;
+    m_fftSize = m_windowSize * (v + 1);
+    
+    m_mutex.unlock();
+
+    emit layerParametersChanged();
+
+    fillCache();
+}
+
+size_t
+SpectrogramLayer::getZeroPadLevel() const
+{
+    return m_zeroPadLevel;
 }
 
 void
 SpectrogramLayer::setWindowType(WindowType w)
 {

 	    input[off + i] = 0.0;
 	}
     }
 
     size_t got = m_model->getValues(m_channel, startFrame + pfx,
-				    endFrame, input + pfx);
+				    endFrame, input + off + pfx);
+
     while (got + pfx < windowSize) {
 	input[off + got + pfx] = 0.0;
 	++got;
     }
 

 		input[off + i] /= channels;
 	    }
 	}
     }
 
-    windower.cut(input);
-
-    for (size_t i = 0; i < windowSize/2; ++i) {
-	fftsample temp = input[off + i];
-	input[off + i] = input[off + i + windowSize/2];
-	input[off + i + windowSize/2] = temp;
+    windower.cut(input + off);
+
+    for (size_t i = 0; i < fftSize/2; ++i) {
+	fftsample temp = input[i];
+	input[i] = input[i + fftSize/2];
+	input[i + fftSize/2] = temp;
     }
 
     fftwf_execute(plan);
 
     fftsample factor = 0.0;
 
     for (size_t i = 0; i < fftSize/2; ++i) {
 
 	fftsample mag = sqrtf(output[i][0] * output[i][0] +
                               output[i][1] * output[i][1]);
-	mag /= fftSize / 2;
+	mag /= windowSize / 2;
 
 	if (mag > factor) factor = mag;
 
 	fftsample phase = atan2f(output[i][1], output[i][0]);
 	phase = princargf(phase);

 //		m_layer.m_cache = new FFTMemoryCache;
 //	    }
             if (!m_layer.m_writeCache) {
                 m_layer.m_writeCache = new FFTFileCache
                     (QString("%1").arg(getObjectExportId(&m_layer)),
-                     MatrixFile::ReadWrite);
+                     MatrixFile::ReadWrite, true);
             }
 	    m_layer.m_writeCache->resize(width, height);
             if (m_layer.m_cache) delete m_layer.m_cache;
             m_layer.m_cache = new FFTFileCache
                 (QString("%1").arg(getObjectExportId(&m_layer)),
-                 MatrixFile::ReadOnly);
+                 MatrixFile::ReadOnly, true);
 
 	    m_layer.setColourmap();
 //!!!	    m_layer.m_writeCache->reset();
 
 	    fftsample *input = (fftsample *)