Log scale for waterfall

plugins/SpectrumAnalyzer/SaControls.cpp

@@ -45,7 +45,7 @@ SaControls::SaControls(Analyzer *effect) :
 
 	m_inProgress(false)
 {
-	m_colorL = QColor(51, 148, 204, 204);
+	m_colorL = QColor(51, 148, 204, 135);
 	m_colorR = QColor(204, 107, 51, 135);
 	m_colorMono = QColor(51, 148, 204, 204);
 	m_colorBG = QColor(7, 7, 7, 255);			// 20 % gray

plugins/SpectrumAnalyzer/SaControls.h

@@ -37,7 +37,16 @@ class Analyzer;
 // FIXME: move this somewhere appropriate
 const int LOWEST_FREQ = 10;		// arbitrary low frequency limit for log. scale (Hz, >0)
 const int LOWEST_AMP = -5;		// arbitrary low amplitude limit for log. scale (10*dB)
+const int RANGE_AUDIBLE_START = 20;
+const int RANGE_AUDIBLE_END = 20000;
+const int RANGE_BASS_START = 20;
+const int RANGE_BASS_END = 300;
+const int RANGE_MID_START = 200;
+const int RANGE_MID_SEND = 5000;
+const int RANGE_HIGH_START = 4000;
+const int RANGE_HIGH_END = 20000;
 const int WATERFALL_HEIGHT = 256;
+
 #define DEBUG 1
 
 class SaControls : public EffectControls

plugins/SpectrumAnalyzer/SaProcessor.cpp

@@ -144,21 +144,49 @@ void SaProcessor::analyse(sampleFrame *in_buffer, const fpp_t frame_count)
 			std::copy(	pixel,
 						pixel + binCount() * WATERFALL_HEIGHT - binCount(),
 						pixel + binCount());
+			memset(pixel, 0, binCount() * sizeof (QRgb));
 
+			int target;
+			float accL = 0;
+			float accR = 0;
+
 			for (int i = 0; i < binCount(); i++) {
-				// apply gamma correction to make small values more visible
-				// (should be around 0.42 to 0.45 for sRGB displays)
-				float ampL = powf(m_normSpectrumL[i], 0.42);
-				float ampR = powf(m_normSpectrumR[i], 0.42);
-
-				if (stereo) {
-					pixel[i] = qRgb(m_controls->m_colorL.red() * ampL + m_controls->m_colorR.red() * ampR,
-									m_controls->m_colorL.green() * ampL + m_controls->m_colorR.green() * ampR,
-									m_controls->m_colorL.blue() * ampL + m_controls->m_colorR.blue() * ampR);
+				if (m_controls->m_logXModel.value()) {
+					// Logarithmic
+					float band_start = freqToXPixel(binToFreq(i) - binBandwidth() / 2.0, binCount() -1);
+					float band_end = freqToXPixel(binToFreq(i + 1) - binBandwidth() / 2.0, binCount() -1);
+
+					if (band_end - band_start > 1.0) {
+						// draw all pixels covered by this band
+						for (target = band_start; target < band_end; target++) {
+							if (target >= 0 && target < binCount()) {
+								pixel[target] = makePixel(m_normSpectrumL[i], m_normSpectrumR[i]);
+							}
+						}
+						accL = (band_end - (int)band_end) * m_normSpectrumL[i];
+						accR = (band_end - (int)band_end) * m_normSpectrumR[i];
+					} else {
+						// sub-pixel drawing; add contribution of current band
+						target = band_start;
+						if ((int)band_start == (int)band_end) {
+							accL += (band_end - band_start) * m_normSpectrumL[i];
+							accR += (band_end - band_start) * m_normSpectrumR[i];
+						} else {
+							// make sure contribution is split correctly on pixel boundary
+							accL += ((int)band_end - band_start) * m_normSpectrumL[i];
+							accR += ((int)band_end - band_start) * m_normSpectrumR[i];
+
+							if (target >= 0 && target < binCount()) {
+								pixel[target] = makePixel(accL, accR);
+							}
+							// save remaining portion of the band for the following band / pixel
+							accL = (band_end - (int)band_end) * m_normSpectrumL[i];
+							accR = (band_end - (int)band_end) * m_normSpectrumR[i];
+						}
+					}
 				} else {
-					pixel[i] = qRgb(m_controls->m_colorMono.lighter().red() * ampL,
-									m_controls->m_colorMono.lighter().green() * ampL,
-									m_controls->m_colorMono.lighter().blue() * ampL);
+					// Linear: simple 1:1 assignment
+					pixel[i] = makePixel(m_normSpectrumL[i], m_normSpectrumR[i]);
 				}
 			}
 
@@ -175,6 +203,63 @@ void SaProcessor::analyse(sampleFrame *in_buffer, const fpp_t frame_count)
 	}
 }
 
+
+QRgb SaProcessor::makePixel(float left, float right) {
+	// apply gamma correction to make small values more visible
+	// (should be around 0.42 to 0.45 for sRGB displays)
+	if (m_controls->m_stereoModel.value()) {
+		float ampL = powf(left, 0.42);
+		float ampR = powf(right, 0.42);
+		return qRgb(m_controls->m_colorL.red() * ampL + m_controls->m_colorR.red() * ampR,
+					m_controls->m_colorL.green() * ampL + m_controls->m_colorR.green() * ampR,
+					m_controls->m_colorL.blue() * ampL + m_controls->m_colorR.blue() * ampR);
+	} else {
+		float ampL = powf(left, 0.42);
+		return qRgb(m_controls->m_colorMono.lighter().red() * ampL,
+					m_controls->m_colorMono.lighter().green() * ampL,
+					m_controls->m_colorMono.lighter().blue() * ampL);
+	}
+}
+
+float SaProcessor::binToFreq(int index)
+{
+	return (index * getSampleRate() / 2.0) / binCount();
+}
+
+float SaProcessor::binBandwidth()
+{
+	return (getSampleRate() / 2.0) / binCount();
+}
+
+float SaProcessor::freqToXPixel(float freq, int width)
+{
+	if (m_controls->m_logXModel.value()) {
+		if (freq <= 1) {return 0;}
+		float min = log10f(LOWEST_FREQ);
+		float max = log10f(getSampleRate() / 2);
+		float range = max - min;
+		return (log10f(freq) - min) / range * width;
+	} else {
+		float range = getSampleRate() / 2;
+		return freq / range * width;
+	}
+}
+
+
+float SaProcessor::ampToYPixel(float amplitude, int height)
+{
+	if (m_controls->m_logYModel.value()){
+		if (log10f(amplitude) < LOWEST_AMP){
+			return height;
+		} else {
+			return height * log10f(amplitude) / LOWEST_AMP;
+		}
+	} else {
+		return height - height * amplitude;
+	}
+}
+
+
 int SaProcessor::getSampleRate() const
 {
 	return m_sampleRate;

plugins/SpectrumAnalyzer/SaProcessor.h

@@ -50,6 +50,11 @@ class SaProcessor
 
 	void reallocateBuffers(int new_size_index);
 
+	float freqToXPixel(float frequency, int width);
+	float ampToYPixel(float amplitude, int height);
+	float binToFreq(int index);
+	float binBandwidth();
+
 	std::mutex m_dataAccess;
 
 private:
@@ -80,6 +85,8 @@ class SaProcessor
 	bool m_active;
 	bool m_inProgress;
 
+	QRgb makePixel(float left, float right);
+
 	friend class SaSpectrumView;
 	friend class SaWaterfallView;
 };

plugins/SpectrumAnalyzer/SaSpectrumView.cpp

@@ -194,8 +194,8 @@ void SaSpectrumView::paintEvent(QPaintEvent *event)
 						(*m_bandHeight)[x] = bands[x];
 					}
 
-					if (freqToXPixel(bandToFreq(x), displayWidth) >= 0) {
-						m_path.lineTo(	freqToXPixel(bandToFreq(x), displayWidth) + displayLeft,
+					if (freqToXPixel(binToFreq(x), displayWidth) >= 0) {
+						m_path.lineTo(	freqToXPixel(binToFreq(x), displayWidth) + displayLeft,
 										ampToYPixel((*m_bandHeight)[x], displayBottom));
 						m_decaySum += (*m_bandHeight)[x];
 					}
@@ -269,39 +269,21 @@ void SaSpectrumView::paintEvent(QPaintEvent *event)
 }
 
 
-float SaSpectrumView::bandToFreq(int index)
+float SaSpectrumView::binToFreq(int index)
 {
-	return index * m_processor->getSampleRate() / (m_processor->binCount() * 2);
+	return m_processor->binToFreq(index);
 }
 
 
 float SaSpectrumView::freqToXPixel(float freq, int width)
 {
-	if (m_controls->m_logXModel.value()){
-		float min = log10f(LOWEST_FREQ);
-		float max = log10f(m_processor->getSampleRate() / 2);
-		float range = max - min;
-		return (log10f(freq) - min) / range * width;
-	} else {
-		float min = LOWEST_FREQ;
-		float max = m_processor->getSampleRate() / 2;
-		float range = max - min;
-		return (freq - min) / range * width;
-	}
+	return m_processor->freqToXPixel(freq, width);
 }
 
 
 float SaSpectrumView::ampToYPixel(float amplitude, int height)
 {
-	if (m_controls->m_logYModel.value()){
-		if (log10f(amplitude) < LOWEST_AMP){
-			return height;
-		} else {
-			return height * log10f(amplitude) / LOWEST_AMP;
-		}
-	} else {
-		return height - height * amplitude;
-	}
+	return m_processor->ampToYPixel(amplitude, height);
 }
 
 

plugins/SpectrumAnalyzer/SaSpectrumView.h

@@ -88,6 +88,6 @@ private slots:
 
 	float freqToXPixel(float frequency, int width);
 	float ampToYPixel(float amplitude, int height);
-	float bandToFreq(int index);
+	float binToFreq(int index);
 };
 #endif // SASPECTRUMVIEW_H