added ability to select 4x upsampling on any plot mode

Author: jniemann66

interpolator.h

@@ -11,7 +11,7 @@
 #define INTERPOLATOR_H
 
 
-//#define INTERPOLATOR_TIME_FUNC
+#define INTERPOLATOR_TIME_FUNC
 
 #ifdef INTERPOLATOR_TIME_FUNC
 #include "movingaverage.h"
@@ -140,6 +140,8 @@ class Interpolator
 	Interpolator()
     {
 		switch(L) {
+		case 1:
+			break;
 		case 2:
 			setCoefficients(coeffs2);
 			break;
@@ -183,6 +185,13 @@ class Interpolator
 		index = fir_length - 1;
 	}
 
+	void reset()
+	{
+		std::fill(history0.begin(), history0.end(), 0.0);
+		std::fill(history1.begin(), history1.end(), 0.0);
+		index = fir_length - 1;
+	}
+
 	void upsampleBlockMono(OutputType* output, const InputType* input, size_t sampleCount)
 	{
 		for(size_t s = 0; s < sampleCount; s++) {
@@ -224,22 +233,11 @@ class Interpolator
 		history0[index] = static_cast<OutputType>(input);
 		size_t p = index;
 
-		if constexpr(L == 2) {
-			output[0] = output[1] = 0.0;
-		} else {
-			for(int k = 0; k < L; k++) {
-				output[k] = 0;
-			}
-		}
+		memset(output, 0.0, L * sizeof(OutputType));
 
 		for(size_t j = 0; j < n * L; j+= L) {
-			if constexpr(L == 2) {
-				output[0] += fir_coeffs[j] * history0[p];
-				output[1] += fir_coeffs[j+1] * history0[p];
-			} else {
-				for(size_t k = 0; k < L; k++) {
-					output[k] += fir_coeffs[j+k] * history0[p];
-				}
+			for(size_t k = 0; k < L; k++) {
+				output[k] += fir_coeffs[j+k] * history0[p];
 			}
 
 			if(++p == fir_length) {
@@ -259,28 +257,13 @@ class Interpolator
 
 		size_t p = index;
 
-		if constexpr(L == 2) {
-			output0[0] = output0[1] = 0.0;
-			output1[0] = output1[1] = 0.0;
-
-		} else {
-			for(int k = 0; k < L; k++) {
-				output0[k] = 0;
-				output1[k] = 0;
-			}
-		}
+		memset(output0, 0.0, L * sizeof(OutputType));
+		memset(output1, 0.0, L * sizeof(OutputType));
 
 		for(size_t j = 0; j < n * L; j+= L) {
-			if constexpr(L == 2) {
-				output0[0] += fir_coeffs[j] * history0[p];
-				output0[1] += fir_coeffs[j+1] * history0[p];
-				output1[0] += fir_coeffs[j] * history1[p];
-				output1[1] += fir_coeffs[j+1] * history1[p];
-			} else {
-				for(size_t k = 0; k < L; k++) {
-					output0[k] += fir_coeffs[j+k] * history0[p];
-					output1[k] += fir_coeffs[j+k] * history1[p];
-				}
+			for(size_t k = 0; k < L; k++) {
+				output0[k] += fir_coeffs[j+k] * history0[p];
+				output1[k] += fir_coeffs[j+k] * history1[p];
 			}
 
 			if(++p == fir_length) {

mainwindow.cpp

@@ -139,17 +139,19 @@ MainWindow::MainWindow(QWidget	*parent) : QMainWindow(parent)
 
 	connect(plotmodeWidget, &PlotmodeWidget::plotmodeChanged, scopeWidget, &ScopeWidget::setPlotmode);
 	connect(plotmodeWidget, &PlotmodeWidget::plotmodeChanged, this, [sweepSettingsWidget](Plotmode plotmode){
-		sweepSettingsWidget->setEnabled(plotmode == Sweep || plotmode == SweepUpsampled);
+		sweepSettingsWidget->setEnabled(plotmode == Sweep);
 	});
 
+	connect(plotmodeWidget, &PlotmodeWidget::upsamplingChanged, scopeWidget, &ScopeWidget::setUpsampling);
+
 	scopeWidget->setBrightness(80.0);
 	scopeWidget->setFocus(80.0);
 	scopeWidget->setPersistence(48);
 
 	sweepSettingsWidget->setSweepParameters(scopeWidget->getSweepParameters());
 	Plotmode plotmode = scopeWidget->getPlotmode();
 	plotmodeWidget->setPlotmode(plotmode);
-	sweepSettingsWidget->setEnabled(plotmode == Sweep || plotmode == SweepUpsampled);
+	sweepSettingsWidget->setEnabled(plotmode == Sweep);
 
 }
 

plotmode.cpp

@@ -4,8 +4,7 @@ QMap<Plotmode, PlotmodeDefinition> PlotmodeManager::plotmodeMap
 {
 	{XY, {XY, "X / Y", "X Axis: Ch0<br/>Y Axis: Ch1"}},
 	{MidSide, {MidSide, "Mid / Side", "X Axis: Ch0 - Ch1<br/>Y Axis: Ch0 + Ch1"}},
-	{Sweep, {Sweep, "Sweep", "X Axis: Sweep<br/>Y Axis: ch0"}},
-	{SweepUpsampled, {SweepUpsampled, "Sweep, Upsampled", "X Axis: Sweep<br/>Y Axis: ch0"}}
+	{Sweep, {Sweep, "Sweep", "X Axis: Sweep<br/>Y Axis: ch0"}}
 };
 
 const QMap<Plotmode, PlotmodeDefinition>& PlotmodeManager::getPlotmodeMap()

plotmode.h

@@ -8,12 +8,9 @@ enum Plotmode
 {
 	XY,
 	MidSide,
-	Sweep,
-	SweepUpsampled
+	Sweep
 };
 
-
-
 struct PlotmodeDefinition
 {
 	Plotmode plotMode;

plotmodewidget.cpp

@@ -8,9 +8,12 @@ PlotmodeWidget::PlotmodeWidget(QWidget *parent)
 	: QWidget{parent}
 {
 	plotmodeSelector = new QComboBox;
+	upsamplingCheckbox = new QCheckBox("upsampling");
+
 	auto plotmodeLayout = new QHBoxLayout;
 	auto mainLayout = new QVBoxLayout;
 	plotmodeLayout->addWidget(plotmodeSelector);
+	plotmodeLayout->addWidget(upsamplingCheckbox);
 
 
 	for (const PlotmodeDefinition& p : PlotmodeManager::getPlotmodeMap())
@@ -29,6 +32,10 @@ PlotmodeWidget::PlotmodeWidget(QWidget *parent)
 		emit plotmodeChanged(getPlotmode());
 	});
 
+	connect(upsamplingCheckbox, &QCheckBox::toggled, this, [this](){
+		emit upsamplingChanged(upsamplingCheckbox->isChecked());
+	});
+
 }
 
 Plotmode PlotmodeWidget::getPlotmode() const

plotmodewidget.h

@@ -5,6 +5,7 @@
 #include <QWidget>
 
 #include <QComboBox>
+#include <QCheckBox>
 
 #include "plotmode.h"
 
@@ -23,9 +24,11 @@ class PlotmodeWidget : public QWidget
 
 signals:
 	void plotmodeChanged(Plotmode plotmode);
+	void upsamplingChanged(bool enableUpsampling);
 
 private:
 	QComboBox *plotmodeSelector{nullptr};
+	QCheckBox *upsamplingCheckbox{nullptr};
 
 };
 

scopewidget.cpp

@@ -10,7 +10,6 @@
 #include "scopewidget.h"
 #include "delayline.h"
 #include "differentiator.h"
-#include "interpolator.h"
 #include "movingaverage.h"
 
 #include <QVBoxLayout>
@@ -44,7 +43,9 @@ ScopeWidget::ScopeWidget(QWidget *parent) : QWidget(parent)
 	const auto divs = scopeDisplay->getDivisions();
 	sweepParameters.horizontalDivisions = divs.first;
 	sweepParameters.verticalDivisions = divs.second;
-	sweepParameters.sweepUnused = {plotMode != Sweep && plotMode != SweepUpsampled};
+	sweepParameters.sweepUnused = {plotMode != Sweep};
+
+	setUpsampling(getUpsampling());
 
 	calcScaling();
     connect(scopeDisplay, &ScopeDisplay::pixmapResolutionChanged, this, [this](){
@@ -53,10 +54,15 @@ ScopeWidget::ScopeWidget(QWidget *parent) : QWidget(parent)
 
 	connect(&plotTimer, &QTimer::timeout, this, [this]{
 		if(!paused) {
-			//plotTest();
+
+		//plotTest();
+			readInput();
+
+			// send audio to output
+			pushOut->write(reinterpret_cast<char*>(rawinputBuffer.data()), framesRead * audioFormat.bytesPerFrame());
+
+			// plot it
 			render();
-            freshRender = true;
-			emit renderedFrame(currentFrame * msPerAudioFrame);
 		}
 	});
 
@@ -89,13 +95,25 @@ QPair<bool, QString> ScopeWidget::loadSoundFile(const QString& filename)
 	if(fileLoaded) {
 
 		// set up rendering parameters, based on soundfile properties
-		inputChannels = sndfile->channels();
-		inputBuffer.resize(sndfile->channels() * sndfile->samplerate()); // 1s of storage
+		numInputChannels = sndfile->channels();
+
+		// initialize raw (interleaved) input buffer
+		rawinputBuffer.resize(numInputChannels * sndfile->samplerate()); // 1s of storage
+
+		// initialize channel input buffers
+		inputBuffers.resize(numInputChannels);
+		for(int ch = 0; ch < numInputChannels; ch++) {
+			size_t chbufSize = sndfile->samplerate() * upsampleFactor; // allow for upsampling
+			inputBuffers[ch].resize(chbufSize);
+		}
+
 		audioFramesPerMs = sndfile->samplerate() / 1000;
+		expectedFrames = plotTimer.interval() * audioFramesPerMs;
 		msPerAudioFrame = 1000.0 / sndfile->samplerate();
 		calcScaling();
 
-		maxFramesToRead = inputBuffer.size() / sndfile->channels();
+		maxFramesToRead = rawinputBuffer.size() / sndfile->channels();
+
 		totalFrames = sndfile->frames();
 		returnToStart();
 
@@ -258,6 +276,40 @@ void ScopeWidget::setTotalFrames(const int64_t &value)
 	totalFrames = value;
 }
 
+void ScopeWidget::readInput()
+{
+	// estimate how far ahead to read
+	const int64_t toFrame = qMin(totalFrames - 1, startFrame + static_cast<int64_t>(elapsedTimer.elapsed() * audioFramesPerMs));
+
+	// read from file
+	framesRead = sndfile->readf(rawinputBuffer.data(), qMin(maxFramesToRead, toFrame - currentFrame));
+	currentFrame += framesRead;
+
+	constexpr bool debugExpectedFrames = false;
+	if constexpr(debugExpectedFrames) {
+		if(framesRead > expectedFrames)
+			qDebug() << "expected" << expectedFrames << "got" << framesRead;
+	}
+
+	// de-interleave
+	if(upsampling && numInputChannels <= 2) {
+		if(numInputChannels == 1) {
+			upsampler.upsampleBlockMono(inputBuffers[0].data(), rawinputBuffer.constData(), framesRead);
+			framesAvailable = framesRead * upsampleFactor;
+		} else if(numInputChannels == 2) {
+			upsampler.upsampleBlockStereo(inputBuffers[0].data(), inputBuffers[1].data(), rawinputBuffer.constData(), framesRead);
+			framesAvailable = framesRead * upsampleFactor;
+		}
+	} else {
+		for(int64_t f = 0ll; f < framesRead; f++) {
+			for(int ch = 0; ch < numInputChannels; ch++) {
+				inputBuffers[ch][f] = rawinputBuffer[f * numInputChannels + ch];
+			}
+		}
+		framesAvailable = framesRead;
+	}
+}
+
 void ScopeWidget::render()
 {
     constexpr size_t historyLength = 10;
@@ -293,14 +345,11 @@ void ScopeWidget::render()
 	constexpr bool catchAllFrames = false;
 	constexpr double rsqrt2 = 0.707;
 	const bool drawLines =  ( sweepParameters.connectDots &&
-							  (plotMode == Sweep || plotMode == SweepUpsampled)  &&
+							  plotMode == Sweep  &&
 							  !panicMode &&
 							  (sweepParameters.getSamplesPerSweep() > 25)
 							  );
 
-	const int64_t expectedFrames = plotTimer.interval() * audioFramesPerMs;
-	const int64_t toFrame = qMin(totalFrames - 1, startFrame + static_cast<int64_t>(elapsedTimer.elapsed() * audioFramesPerMs));
-	const int64_t framesRead = sndfile->readf(inputBuffer.data(), qMin(maxFramesToRead, toFrame - currentFrame));
 
     auto pixmap = scopeDisplay->getPixmap();
     QPainter painter(pixmap);
@@ -323,21 +372,15 @@ void ScopeWidget::render()
 				Qt::BevelJoin};
 	painter.setPen(pen);
 
-    constexpr bool debugExpectedFrames = false;
-    if constexpr(debugExpectedFrames) {
-		if(framesRead > expectedFrames)
-			qDebug() << "expected" << expectedFrames << "got" << framesRead;
-	}
-
-	int64_t firstFrameToPlot = catchAllFrames ? 0ll : std::max(0ll, framesRead - expectedFrames * 2);
-
+	int64_t expected = expectedFrames * (upsampling ? upsampleFactor : 1);
+	int64_t firstFrameToPlot = catchAllFrames ? 0ll : std::max(0ll, framesAvailable - 2 * expected);
 
 	// draw
 	const double w = 2.0 * cx;
-	for(int64_t i = firstFrameToPlot; i < inputChannels * framesRead; i+= inputChannels) {
+	for(int64_t i = firstFrameToPlot; i < framesAvailable; i++) {
 
-		double ch0val = inputBuffer.at(i);
-		double ch1val = (inputChannels > 1 ? inputBuffer.at(i + 1) : 0.0);
+		double ch0val = inputBuffers[0][i];
+		double ch1val = (numInputChannels > 1 ? inputBuffers[1][i] : 0.0);
 
 		switch(plotMode) {
 		case XY:
@@ -380,44 +423,6 @@ void ScopeWidget::render()
 		}
 			break;
 
-		case SweepUpsampled:
-		{
-			constexpr int upsampleFactor = 4;
-			static Interpolator<float, double, upsampleFactor> upsampler;
-			static Differentiator<double> d;
-			static DelayLine<double, d.delayTime> delayLine;
-			static bool triggered = false;
-			static double x = 0.0;
-			static QPointF lastPoint{0.0, cy * (1.0 - sweepParameters.triggerLevel)};
-			const double &source = ch0val;
-
-			double upsampled[upsampleFactor];
-			upsampler.upsampleSingleMono(upsampled, source);
-			for(int u = 0; u < upsampleFactor; u++) {
-				double slope = d.get(upsampled[u]) * sweepParameters.slope;
-				double delayed = delayLine.get(upsampled[u]);
-
-				triggered = triggered
-							|| !sweepParameters.triggerEnabled // when trigger disabled -> Always Triggered
-							|| (sweepParameters.triggerMin <= delayed && delayed <= sweepParameters.triggerMax && slope > 0.0);
-
-				if(triggered) {
-					QPointF pt{x, cy * (1.0 - delayed)};
-					if(drawLines)  {
-						plotBuffer.append(lastPoint);
-					}
-					lastPoint = pt;
-					plotBuffer.append(pt);
-					x += sweepParameters.sweepAdvanceInterpolated;
-					if(x > w) { // sweep completed
-						x = 0.0;
-						triggered = false;
-						lastPoint = {x, cy * (1.0 - sweepParameters.triggerLevel)};
-					}
-				}
-			}
-		}
-
 		} // ends switch
 	} // ends loop over i
 
@@ -428,10 +433,6 @@ void ScopeWidget::render()
 	}
 	plotBuffer.clear();
 
-	const int bytesPerFrame = audioFormat.bytesPerFrame();
-	pushOut->write(reinterpret_cast<char*>(inputBuffer.data()), framesRead * bytesPerFrame);
-	currentFrame += framesRead;
-
     constexpr bool debugPlotBufferSize = false;
 	if constexpr(debugPlotBufferSize) {
 		static decltype(plotBuffer.size()) maxSize = 0ll;
@@ -446,6 +447,8 @@ void ScopeWidget::render()
 	}
 
 	painter.endNativePainting();
+	freshRender = true;
+	emit renderedFrame(currentFrame * msPerAudioFrame);
 }
 
 void ScopeWidget::plotTest()
@@ -556,13 +559,27 @@ Plotmode ScopeWidget::getPlotmode() const
 void ScopeWidget::setPlotmode(Plotmode newPlotmode)
 {
 	plotMode = newPlotmode;
-	if(plotMode == Sweep || plotMode == SweepUpsampled) {
+	if(plotMode == Sweep) {
 		//
 	} else {
 		sweepParameters.sweepUnused = true;
 	}
 }
 
+bool ScopeWidget::getUpsampling() const
+{
+	return upsampling;
+}
+
+void ScopeWidget::setUpsampling(bool val)
+{
+	upsampling = val;
+	sweepParameters.setUpsampleFactor(upsampling ? static_cast<double>(upsampleFactor) : 1.0);
+	if(upsampling) {
+		upsampler.reset();
+	}
+}
+
 void ScopeWidget::calcScaling()
 {
     auto pixmap = scopeDisplay->getPixmap();
@@ -579,6 +596,8 @@ void ScopeWidget::calcScaling()
 	sweepParameters.setWidthFrameRate(w, audioFramesPerMs);
 }
 
+
+
 void ScopeWidget::setAudioVolume(qreal linearVolume)
 {
 	audioController->setOutputVolume(linearVolume);
@@ -615,7 +634,7 @@ bool ScopeWidget::getShowTrigger() const
 
 void ScopeWidget::setShowTrigger(bool val)
 {
-	showTrigger = (plotMode == Sweep || plotMode == SweepUpsampled) && val;
+	showTrigger = (plotMode == Sweep) && val;
 	if(paused) {
 
 		auto pixmap = scopeDisplay->getPixmap();

scopewidget.h

@@ -31,6 +31,7 @@
 #include "plotmode.h"
 #include "sweepparameters.h"
 #include "audiocontroller.h"
+#include "interpolator.h"
 
 // ScopeDisplay : this is the Oscilloscope's screen
 // it owns a QPixmap as an image buffer, which is accessed via getPixmap()
@@ -207,6 +208,8 @@ class ScopeWidget : public QWidget
 {
 	Q_OBJECT
 
+	static constexpr int upsampleFactor = 4;
+
 public:
 	explicit ScopeWidget(QWidget *parent = nullptr);
 	QPair<bool, QString> loadSoundFile(const QString &filename);
@@ -236,15 +239,18 @@ class ScopeWidget : public QWidget
 	void setBackgroundColor(const QColor &value);
 	void setOutputDevice(const QAudioDeviceInfo &newOutputDeviceInfo);
 	void setShowTrigger(bool val);
-
 	void plotTest();
+
+	bool getUpsampling() const;
+
 public slots:
 	void returnToStart();
 	void gotoPosition(int64_t milliSeconds);
 	void wipeScreen();
 	void setAudioVolume(qreal linearVolume);
 	void setSweepParameters(const SweepParameters &newSweepParameters);
 	void setPlotmode(Plotmode newPlotmode);
+	void setUpsampling(bool val);
 
 signals:
 	void loadedFile();
@@ -258,30 +264,46 @@ public slots:
 	AudioController *audioController{nullptr};
 	QIODevice* pushOut{nullptr};
 	QHBoxLayout *screenLayout{nullptr};
-
 	std::unique_ptr<SndfileHandle> sndfile;
-	QVector<float> inputBuffer;
 	QAudioFormat audioFormat;
 	QAudioDeviceInfo outputDeviceInfo;
+	Interpolator<float, float, upsampleFactor> upsampler;
+
+	// audio buffers
+	QVector<float> rawinputBuffer; // interleaved
+	QVector<QVector<float>> inputBuffers; // de-interleaved
+
+	// timing
 	QTimer plotTimer;
     QTimer screenUpdateTimer;
 	QElapsedTimer elapsedTimer;
 
+	// plot buffers
 	QVector<QPointF> testPlot;
 	QVector<QPointF> plotBuffer;
 
 	Plotmode plotMode{XY};
 	bool showTrigger{false};
 	SweepParameters sweepParameters;
-	int inputChannels{0};
+
+	bool upsampling{false};
+	int numInputChannels{0};
 	int audioFramesPerMs{0};
 	double msPerAudioFrame{0.0};
-	int64_t startFrame{0};
-	int64_t currentFrame{0ll};
-	int64_t maxFramesToRead{0};
-	int64_t totalFrames{0ll};
+
+	// audio frame accounting
+	int64_t startFrame{0ll}; // start position for playback
+	int64_t currentFrame{0ll}; // start position of next read
+	int64_t framesRead{0ll}; // number of audioframes last read from file
+	int64_t framesAvailable{011}; // number of audioframes currently stored in input buffers; after upsampling
+	int64_t expectedFrames{0ll}; // number of audioframes expected per plotTimer timeout
+	int64_t maxFramesToRead{0ll}; // limit of how many audioframes can fit in buffer
+	int64_t totalFrames{0ll}; // total number of audioframes in sound file
+
 	bool fileLoaded{false};
 	bool paused{true};
+
+	// crt properties
 	double brightness{80.0};
 	double focus{80.0};
 	double persistence{32.0};
@@ -291,26 +313,27 @@ public slots:
 	QColor darkencolor{0, 0, 0, 0};
 	QColor backgroundColor{0, 0, 0, 255};
 	QPainter::CompositionMode compositionMode{QPainter::CompositionMode_SourceOver};
+	int darkenAlpha;
+	int beamAlpha;
+	double beamWidth;
+	double beamIntensity;
+
     bool freshRender{false};
 
-	// midpoint of pixmap
+	// plot dimensions
 	double cx;
 	double cy;
 	double w;
 	double h;
 	double divx;
 	double divy;
 
-	int darkenAlpha;
-	int beamAlpha;
-	double beamWidth;
-	double beamIntensity;
-
+	// private functions
 	void calcScaling();
+	void readInput();
 	void render();
 	void renderTest();
 	void calcBeamAlpha();
-
 	void renderTrigger(QPainter *painter);
 	void makeTestPlot();
 signals:

sndscope.pro

@@ -10,9 +10,9 @@ QT += core gui multimedia widgets
 CONFIG += c++17
 
 # force -O3
-# QMAKE_CXXFLAGS_RELEASE -= -O2
-# QMAKE_CXXFLAGS_RELEASE += -O3
-# QMAKE_CXXFLAGS_RELEASE += -mavx2
+ QMAKE_CXXFLAGS_RELEASE -= -O2
+ QMAKE_CXXFLAGS_RELEASE += -O3
+ QMAKE_CXXFLAGS_RELEASE += -mavx2
 # --
 
 #import libsndfile

sweepparameters.h

@@ -47,6 +47,8 @@ struct SweepParameters
 
 	bool getConnectDots() const;
 
+	double getUpsampleFactor() const;
+
 	static QString formatMeasurementUnits(double duration_s, const QString& units, int precision = 2)
 	{
 		// constexpr int m = 999;
@@ -90,10 +92,13 @@ struct SweepParameters
 
 
 
+	void setUpsampleFactor(double newUpsampleFactor);
+
 private:
 	double duration_ms{10.0};
 	int width_pixels{640};
 	double inputFrames_per_ms{44.1};
+	double upsampleFactor{1.0};
 	double sweepAdvance; // pixels per input frame
 	double sweepAdvanceInterpolated;
 	double triggerMin{triggerLevel - triggerTolerance};
@@ -109,8 +114,7 @@ struct SweepParameters
 
 	void calcSweepAdvance()
 	{
-		sweepAdvance = width_pixels / inputFrames_per_ms / duration_ms;
-		sweepAdvanceInterpolated = sweepAdvance / 4;
+		sweepAdvance = width_pixels / inputFrames_per_ms / duration_ms / upsampleFactor;
 	}
 };
 
@@ -119,6 +123,17 @@ inline bool SweepParameters::getConnectDots() const
 	return connectDots;
 }
 
+inline double SweepParameters::getUpsampleFactor() const
+{
+	return upsampleFactor;
+}
+
+inline void SweepParameters::setUpsampleFactor(double newUpsampleFactor)
+{
+	upsampleFactor = newUpsampleFactor;
+	calcSweepAdvance();
+}
+
 inline void SweepParameters::setConnectDots(bool newConnectDots)
 {
 	connectDots = newConnectDots;