Experimental demodulator preprocessor thread

Demodulator becoming a CPU hotspot, trying to break up the workload
between threads..

CMakeLists.txt

@@ -125,6 +125,7 @@ SET (cubicsdr_sources
 	src/AppFrame.cpp
 	src/sdr/SDRThread.cpp
 	src/sdr/SDRPostThread.cpp
+	src/demod/DemodulatorPreThread.cpp
 	src/demod/DemodulatorThread.cpp
 	src/demod/DemodulatorWorkerThread.cpp
 	src/demod/DemodulatorInstance.cpp
@@ -151,6 +152,7 @@ SET (cubicsdr_headers
 	src/AppFrame.h
 	src/sdr/SDRThread.h
 	src/sdr/SDRPostThread.h
+	src/demod/DemodulatorPreThread.h
 	src/demod/DemodulatorThread.h
 	src/demod/DemodulatorWorkerThread.h
 	src/demod/DemodulatorInstance.h

src/demod/DemodDefs.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include "ThreadQueue.h"
+#include "CubicSDRDefs.h"
+#include "liquid/liquid.h"
 
 enum DemodulatorType {
 	DEMOD_TYPE_NULL,
@@ -17,6 +19,7 @@ public:
 		DEMOD_THREAD_CMD_NULL,
 		DEMOD_THREAD_CMD_SET_BANDWIDTH,
 		DEMOD_THREAD_CMD_SET_FREQUENCY,
+		DEMOD_THREAD_CMD_DEMOD_PREPROCESS_TERMINATED,
 		DEMOD_THREAD_CMD_DEMOD_TERMINATED,
 		DEMOD_THREAD_CMD_AUDIO_TERMINATED
 	};
@@ -58,6 +61,22 @@ public:
 	}
 };
 
+class DemodulatorThreadPostIQData {
+public:
+	std::vector<liquid_float_complex> data;
+	float audio_resample_ratio;
+	msresamp_crcf audio_resampler;
+
+	DemodulatorThreadPostIQData(): audio_resample_ratio(0), audio_resampler(NULL) {
+
+	}
+
+	~DemodulatorThreadPostIQData() {
+
+	}
+};
+
+
 class DemodulatorThreadAudioData {
 public:
 	unsigned int frequency;
@@ -84,4 +103,26 @@ public:
 };
 
 typedef ThreadQueue<DemodulatorThreadIQData> DemodulatorThreadInputQueue;
+typedef ThreadQueue<DemodulatorThreadPostIQData> DemodulatorThreadPostInputQueue;
 typedef ThreadQueue<DemodulatorThreadCommand> DemodulatorThreadCommandQueue;
+
+
+class DemodulatorThreadParameters {
+public:
+    unsigned int frequency;
+    unsigned int inputRate;
+    unsigned int bandwidth; // set equal to disable second stage re-sampling?
+    unsigned int audioSampleRate;
+
+    DemodulatorType demodType;
+
+    DemodulatorThreadParameters() :
+            frequency(0), inputRate(SRATE), bandwidth(200000), audioSampleRate(
+                    AUDIO_FREQUENCY), demodType(DEMOD_TYPE_FM) {
+
+    }
+
+    ~DemodulatorThreadParameters() {
+
+    }
+};

src/demod/DemodulatorInstance.cpp

@@ -1,87 +1,137 @@
 #include "DemodulatorInstance.h"
 
 DemodulatorInstance::DemodulatorInstance() :
-        t_Demod(NULL), t_Audio(NULL), threadQueueDemod(NULL), demodulatorThread(NULL), terminated(false), audioTerminated(false), demodTerminated(
+		t_Demod(NULL), t_PreDemod(NULL), t_Audio(NULL), threadQueueDemod(NULL), demodulatorThread(NULL), terminated(false), audioTerminated(false), demodTerminated(
-        false) {
+				false), preDemodTerminated(false) {
 
-    label = new std::string("Unnamed");
+	label = new std::string("Unnamed");
-    threadQueueDemod = new DemodulatorThreadInputQueue;
+	threadQueueDemod = new DemodulatorThreadInputQueue;
-    threadQueueCommand = new DemodulatorThreadCommandQueue;
+	threadQueuePostDemod = new DemodulatorThreadPostInputQueue;
-    threadQueueNotify = new DemodulatorThreadCommandQueue;
+	threadQueueCommand = new DemodulatorThreadCommandQueue;
-    demodulatorThread = new DemodulatorThread(threadQueueDemod, threadQueueNotify);
+	threadQueueNotify = new DemodulatorThreadCommandQueue;
-    demodulatorThread->setCommandQueue(threadQueueCommand);
+
-    audioInputQueue = new AudioThreadInputQueue;
+	demodulatorPreThread = new DemodulatorPreThread(threadQueueDemod, threadQueuePostDemod, threadQueueNotify);
-    audioThread = new AudioThread(audioInputQueue, threadQueueNotify);
+	demodulatorPreThread->setCommandQueue(threadQueueCommand);
-    demodulatorThread->setAudioInputQueue(audioInputQueue);
+	demodulatorThread = new DemodulatorThread(threadQueuePostDemod, threadQueueNotify);
+
+	audioInputQueue = new AudioThreadInputQueue;
+	audioThread = new AudioThread(audioInputQueue, threadQueueNotify);
+
+	demodulatorThread->setAudioInputQueue(audioInputQueue);
 }
 
 DemodulatorInstance::~DemodulatorInstance() {
-    delete audioThread;
+	delete audioThread;
-    delete demodulatorThread;
+	delete demodulatorThread;
 
-    delete audioInputQueue;
+	delete audioInputQueue;
-    delete threadQueueDemod;
+	delete threadQueueDemod;
 }
 
 void DemodulatorInstance::setVisualOutputQueue(DemodulatorThreadOutputQueue *tQueue) {
-    demodulatorThread->setVisualOutputQueue(tQueue);
+	demodulatorThread->setVisualOutputQueue(tQueue);
 }
 
 void DemodulatorInstance::run() {
-    t_Audio = new std::thread(&AudioThread::threadMain, audioThread);
+	t_Audio = new std::thread(&AudioThread::threadMain, audioThread);
 
 #ifdef __APPLE__    // Already using pthreads, might as well do some custom init..
-    pthread_attr_t attr;
+	pthread_attr_t attr;
-    size_t size;
+	size_t size;
 
-    pthread_attr_init(&attr);
+	pthread_attr_init(&attr);
-    pthread_attr_setstacksize(&attr, 2048000);
+	pthread_attr_setstacksize(&attr, 2048000);
-    pthread_attr_getstacksize(&attr, &size);
+	pthread_attr_getstacksize(&attr, &size);
-    pthread_create(&t_Demod, &attr, &DemodulatorThread::pthread_helper, demodulatorThread);
+	pthread_create(&t_PreDemod, &attr, &DemodulatorPreThread::pthread_helper, demodulatorPreThread);
-    pthread_attr_destroy(&attr);
+	pthread_attr_destroy(&attr);
 
-    std::cout << "Initialized demodulator stack size of " << size << std::endl;
+	pthread_attr_init(&attr);
+	pthread_attr_setstacksize(&attr, 2048000);
+	pthread_attr_getstacksize(&attr, &size);
+	pthread_create(&t_Demod, &attr, &DemodulatorThread::pthread_helper, demodulatorThread);
+	pthread_attr_destroy(&attr);
+
+	std::cout << "Initialized demodulator stack size of " << size << std::endl;
 
 #else
-    t_Demod = new std::thread(&DemodulatorThread::threadMain, demodulatorThread);
+	t_PreDemod = new std::thread(&DemodulatorPreThread::threadMain, demodulatorPreThread);
+	t_Demod = new std::thread(&DemodulatorThread::threadMain, demodulatorThread);
 #endif
 }
 
 void DemodulatorInstance::updateLabel(int freq) {
-    std::stringstream newLabel;
+	std::stringstream newLabel;
-    newLabel.precision(3);
+	newLabel.precision(3);
-    newLabel << std::fixed << ((float) freq / 1000000.0);
+	newLabel << std::fixed << ((float) freq / 1000000.0);
-    setLabel(newLabel.str());
+	setLabel(newLabel.str());
 }
 
 DemodulatorThreadCommandQueue *DemodulatorInstance::getCommandQueue() {
-    return threadQueueCommand;
+	return threadQueueCommand;
 }
 
 DemodulatorThreadParameters &DemodulatorInstance::getParams() {
-    return demodulatorThread->getParams();
+	return demodulatorPreThread->getParams();
 }
 
 void DemodulatorInstance::terminate() {
-    std::cout << "Terminating demodulator thread.." << std::endl;
+	std::cout << "Terminating demodulator preprocessor thread.." << std::endl;
-    demodulatorThread->terminate();
+	demodulatorPreThread->terminate();
-//#ifdef __APPLE__
+	std::cout << "Terminating demodulator thread.." << std::endl;
-//    pthread_join(t_Demod,NULL);
+	demodulatorThread->terminate();
-//#else
+	std::cout << "Terminating demodulator audio thread.." << std::endl;
-//#endif
+	audioThread->terminate();
-    std::cout << "Terminating demodulator audio thread.." << std::endl;
-    audioThread->terminate();
 }
 
 std::string DemodulatorInstance::getLabel() {
-    return *(label.load());
+	return *(label.load());
 }
 
 void DemodulatorInstance::setLabel(std::string labelStr) {
-    std::string *newLabel = new std::string;
+	std::string *newLabel = new std::string;
-    newLabel->append(labelStr);
+	newLabel->append(labelStr);
-    std::string *oldLabel;
+	std::string *oldLabel;
-    oldLabel = label;
+	oldLabel = label;
-    label = newLabel;
+	label = newLabel;
-    delete oldLabel;
+	delete oldLabel;
 }
+
+bool DemodulatorInstance::isTerminated() {
+	while (!threadQueueNotify->empty()) {
+		DemodulatorThreadCommand cmd;
+		threadQueueNotify->pop(cmd);
+
+		switch (cmd.cmd) {
+		case DemodulatorThreadCommand::DEMOD_THREAD_CMD_AUDIO_TERMINATED:
+			audioThread = NULL;
+			t_Audio->join();
+			audioTerminated = true;
+			break;
+		case DemodulatorThreadCommand::DEMOD_THREAD_CMD_DEMOD_TERMINATED:
+			demodulatorThread = NULL;
+#ifdef __APPLE__
+			pthread_join(t_Demod, NULL);
+#else
+			t_Demod->join();
+#endif
+			demodTerminated = true;
+			break;
+		case DemodulatorThreadCommand::DEMOD_THREAD_CMD_DEMOD_PREPROCESS_TERMINATED:
+			demodulatorPreThread = NULL;
+#ifdef __APPLE__
+			pthread_join(t_PreDemod, NULL);
+#else
+			t_PreDemod->join();
+#endif
+			preDemodTerminated = true;
+			break;
+		default:
+			break;
+		}
+	}
+
+	terminated = audioTerminated && demodTerminated && preDemodTerminated;
+
+	return terminated;
+}
+

src/demod/DemodulatorInstance.h

@@ -5,17 +5,22 @@
 #include <thread>
 
 #include "DemodulatorThread.h"
+#include "DemodulatorPreThread.h"
 
 class DemodulatorInstance {
 public:
 
     DemodulatorThreadInputQueue* threadQueueDemod;
+    DemodulatorThreadPostInputQueue* threadQueuePostDemod;
     DemodulatorThreadCommandQueue* threadQueueCommand;
     DemodulatorThreadCommandQueue* threadQueueNotify;
+    DemodulatorPreThread *demodulatorPreThread;
     DemodulatorThread *demodulatorThread;
 #ifdef __APPLE__
+    pthread_t t_PreDemod;
     pthread_t t_Demod;
 #else
+    std::thread *t_PreDemod;
     std::thread *t_Demod;
 #endif
 
@@ -44,6 +49,7 @@ private:
     bool terminated;
     bool demodTerminated;
     bool audioTerminated;
+    bool preDemodTerminated;
 };
 
 

src/demod/DemodulatorMgr.cpp

@@ -5,169 +5,138 @@
 #include <string>
 #include <sstream>
 
-
 DemodulatorMgr::DemodulatorMgr() :
-        activeDemodulator(NULL), lastActiveDemodulator(NULL), activeVisualDemodulator(NULL) {
+		activeDemodulator(NULL), lastActiveDemodulator(NULL), activeVisualDemodulator(NULL) {
 
 }
 
 DemodulatorMgr::~DemodulatorMgr() {
-    terminateAll();
+	terminateAll();
 }
 
 DemodulatorInstance *DemodulatorMgr::newThread() {
-    DemodulatorInstance *newDemod = new DemodulatorInstance;
+	DemodulatorInstance *newDemod = new DemodulatorInstance;
 
-    demods.push_back(newDemod);
+	demods.push_back(newDemod);
 
-    std::stringstream label;
+	std::stringstream label;
-    label << demods.size();
+	label << demods.size();
-    newDemod->setLabel(label.str());
+	newDemod->setLabel(label.str());
 
-    return newDemod;
+	return newDemod;
 }
 
 void DemodulatorMgr::terminateAll() {
-    while (demods.size()) {
+	while (demods.size()) {
-        DemodulatorInstance *d = demods.back();
+		DemodulatorInstance *d = demods.back();
-        deleteThread(d);
+		deleteThread(d);
-    }
+	}
 }
 
 std::vector<DemodulatorInstance *> &DemodulatorMgr::getDemodulators() {
-    return demods;
+	return demods;
 }
 
 void DemodulatorMgr::deleteThread(DemodulatorInstance *demod) {
-    std::vector<DemodulatorInstance *>::iterator i;
+	std::vector<DemodulatorInstance *>::iterator i;
 
-    i = std::find(demods.begin(), demods.end(), demod);
+	i = std::find(demods.begin(), demods.end(), demod);
 
-    if (activeDemodulator == demod) {
+	if (activeDemodulator == demod) {
-        activeDemodulator = NULL;
+		activeDemodulator = NULL;
-    }
+	}
-    if (lastActiveDemodulator == demod) {
+	if (lastActiveDemodulator == demod) {
-        lastActiveDemodulator = NULL;
+		lastActiveDemodulator = NULL;
-    }
+	}
-    if (activeVisualDemodulator == demod) {
+	if (activeVisualDemodulator == demod) {
-        activeVisualDemodulator = NULL;
+		activeVisualDemodulator = NULL;
-    }
+	}
 
-    if (i != demods.end()) {
+	if (i != demods.end()) {
-        demods.erase(i);
+		demods.erase(i);
-        demod->terminate();
+		demod->terminate();
-    }
+	}
 
-    demods_deleted.push_back(demod);
+	demods_deleted.push_back(demod);
 
-    garbageCollect();
+	garbageCollect();
 }
 
 std::vector<DemodulatorInstance *> *DemodulatorMgr::getDemodulatorsAt(int freq, int bandwidth) {
-    std::vector<DemodulatorInstance *> *foundDemods = new std::vector<DemodulatorInstance *>();
+	std::vector<DemodulatorInstance *> *foundDemods = new std::vector<DemodulatorInstance *>();
 
-    for (int i = 0, iMax = demods.size(); i < iMax; i++) {
+	for (int i = 0, iMax = demods.size(); i < iMax; i++) {
-        DemodulatorInstance *testDemod = demods[i];
+		DemodulatorInstance *testDemod = demods[i];
 
-        int freqTest = testDemod->getParams().frequency;
+		int freqTest = testDemod->getParams().frequency;
-        int bandwidthTest = testDemod->getParams().bandwidth;
+		int bandwidthTest = testDemod->getParams().bandwidth;
-        int halfBandwidthTest = bandwidthTest / 2;
+		int halfBandwidthTest = bandwidthTest / 2;
 
-        int halfBuffer = bandwidth / 2;
+		int halfBuffer = bandwidth / 2;
 
-        if ((freq <= (freqTest + halfBandwidthTest + halfBuffer)) && (freq >= (freqTest - halfBandwidthTest - halfBuffer))) {
+		if ((freq <= (freqTest + halfBandwidthTest + halfBuffer)) && (freq >= (freqTest - halfBandwidthTest - halfBuffer))) {
-            foundDemods->push_back(testDemod);
+			foundDemods->push_back(testDemod);
-        }
+		}
-    }
+	}
 
-    return foundDemods;
+	return foundDemods;
 }
 
 void DemodulatorMgr::setActiveDemodulator(DemodulatorInstance *demod, bool temporary) {
-    if (!temporary) {
+	if (!temporary) {
-        if (activeDemodulator != NULL) {
+		if (activeDemodulator != NULL) {
-            lastActiveDemodulator = activeDemodulator;
+			lastActiveDemodulator = activeDemodulator;
-        } else {
+		} else {
-            lastActiveDemodulator = demod;
+			lastActiveDemodulator = demod;
-        }
+		}
-    }
+	}
 
-    if (activeVisualDemodulator) {
+	if (activeVisualDemodulator) {
-        activeVisualDemodulator->setVisualOutputQueue(NULL);
+		activeVisualDemodulator->setVisualOutputQueue(NULL);
-    }
+	}
-    if (demod) {
+	if (demod) {
-        demod->setVisualOutputQueue(wxGetApp().getAudioVisualQueue());
+		demod->setVisualOutputQueue(wxGetApp().getAudioVisualQueue());
-        activeVisualDemodulator = demod;
+		activeVisualDemodulator = demod;
-    } else {
+	} else {
-        DemodulatorInstance *last = getLastActiveDemodulator();
+		DemodulatorInstance *last = getLastActiveDemodulator();
-        if (last) {
+		if (last) {
-            last->setVisualOutputQueue(wxGetApp().getAudioVisualQueue());
+			last->setVisualOutputQueue(wxGetApp().getAudioVisualQueue());
-        }
+		}
-        activeVisualDemodulator = last;
+		activeVisualDemodulator = last;
-    }
+	}
 
-    activeDemodulator = demod;
+	activeDemodulator = demod;
 
-    garbageCollect();
+	garbageCollect();
 }
 
 DemodulatorInstance *DemodulatorMgr::getActiveDemodulator() {
-    return activeDemodulator;
+	return activeDemodulator;
 }
 
 DemodulatorInstance *DemodulatorMgr::getLastActiveDemodulator() {
-    if (std::find(demods.begin(), demods.end(), lastActiveDemodulator) == demods.end()) {
+	if (std::find(demods.begin(), demods.end(), lastActiveDemodulator) == demods.end()) {
-        lastActiveDemodulator = activeDemodulator;
+		lastActiveDemodulator = activeDemodulator;
-    }
+	}
 
-    return lastActiveDemodulator;
+	return lastActiveDemodulator;
 }
 
 void DemodulatorMgr::garbageCollect() {
-    if (demods_deleted.size()) {
+	if (demods_deleted.size()) {
-        std::vector<DemodulatorInstance *>::iterator i;
+		std::vector<DemodulatorInstance *>::iterator i;
 
-        for (i = demods_deleted.begin(); i != demods_deleted.end(); i++) {
+		for (i = demods_deleted.begin(); i != demods_deleted.end(); i++) {
-            if ((*i)->isTerminated()) {
+			if ((*i)->isTerminated()) {
-                DemodulatorInstance *deleted = (*i);
+				DemodulatorInstance *deleted = (*i);
-                demods_deleted.erase(i);
+				demods_deleted.erase(i);
 
-                std::cout << "Garbage collected demodulator instance " << deleted->getLabel() << std::endl;
+				std::cout << "Garbage collected demodulator instance " << deleted->getLabel() << std::endl;
 
-                delete deleted;
+				delete deleted;
-                return;
+				return;
-            }
+			}
-        }
+		}
-    }
+	}
-}
-
-bool DemodulatorInstance::isTerminated() {
-    while (!threadQueueNotify->empty()) {
-        DemodulatorThreadCommand cmd;
-        threadQueueNotify->pop(cmd);
-
-        switch (cmd.cmd) {
-        case DemodulatorThreadCommand::DEMOD_THREAD_CMD_AUDIO_TERMINATED:
-            audioThread = NULL;
-            t_Audio->join();
-            audioTerminated = true;
-            break;
-        case DemodulatorThreadCommand::DEMOD_THREAD_CMD_DEMOD_TERMINATED:
-            demodulatorThread = NULL;
-#ifdef __APPLE__
-            pthread_join(t_Demod,NULL);
-#else
-            t_Demod->join();
-#endif
-            demodTerminated = true;
-            break;
-        default:
-            break;
-        }
-    }
-
-    terminated = audioTerminated && demodTerminated;
-
-    return terminated;
 }
 

src/demod/DemodulatorPreThread.cpp

@@ -1,4 +1,4 @@
-#include "DemodulatorThread.h"
+
 #include "CubicSDRDefs.h"
 #include <vector>
 
@@ -6,8 +6,10 @@
 #include <pthread.h>
 #endif
 
-DemodulatorThread::DemodulatorThread(DemodulatorThreadInputQueue* pQueue, DemodulatorThreadCommandQueue* threadQueueNotify) :
+#include "DemodulatorPreThread.h"
-        inputQueue(pQueue), visOutQueue(NULL), terminated(false), initialized(false), audio_resampler(NULL), resample_ratio(1), audio_resample_ratio(
+
+DemodulatorPreThread::DemodulatorPreThread(DemodulatorThreadInputQueue* pQueueIn, DemodulatorThreadPostInputQueue* pQueueOut, DemodulatorThreadCommandQueue* threadQueueNotify) :
+        inputQueue(pQueueIn), postInputQueue(pQueueOut), terminated(false), initialized(false), audio_resampler(NULL), resample_ratio(1), audio_resample_ratio(
                 1), resampler(NULL), commandQueue(NULL), fir_filter(NULL), audioInputQueue(NULL), threadQueueNotify(threadQueueNotify) {
 
     float kf = 0.5;         // modulation factor
@@ -24,7 +26,7 @@ DemodulatorThread::DemodulatorThread(DemodulatorThreadInputQueue* pQueue, Demodu
     t_Worker = new std::thread(&DemodulatorWorkerThread::threadMain, workerThread);
 }
 
-void DemodulatorThread::initialize() {
+void DemodulatorPreThread::initialize() {
     initialized = false;
 
     resample_ratio = (float) (params.bandwidth) / (float) params.inputRate;
@@ -74,26 +76,24 @@ void DemodulatorThread::initialize() {
     last_params = params;
 }
 
-DemodulatorThread::~DemodulatorThread() {
+DemodulatorPreThread::~DemodulatorPreThread() {
     delete workerThread;
     delete workerQueue;
     delete workerResults;
 }
 
 #ifdef __APPLE__
-void *DemodulatorThread::threadMain() {
+void *DemodulatorPreThread::threadMain() {
 #else
-void DemodulatorThread::threadMain() {
+void DemodulatorPreThread::threadMain() {
 #endif
 
     if (!initialized) {
         initialize();
     }
 
-    liquid_float_complex *in_buf = new liquid_float_complex[BUF_SIZE / 2];
-    liquid_float_complex *out_buf = new liquid_float_complex[BUF_SIZE / 2];
 
-    std::cout << "Demodulator thread started.." << std::endl;
+    std::cout << "Demodulator preprocessor thread started.." << std::endl;
     while (!terminated) {
         DemodulatorThreadIQData inp;
         inputQueue->pop(inp);
@@ -154,66 +154,47 @@ void DemodulatorThread::threadMain() {
 
         std::vector<signed char> *data = &inp.data;
         if (data->size()) {
-            liquid_float_complex *temp_buf;
+        	int bufSize = data->size() / 2;
 
-            for (int i = 0; i < BUF_SIZE / 2; i++) {
+            liquid_float_complex in_buf_data[bufSize];
+            liquid_float_complex out_buf_data[bufSize];
+
+            liquid_float_complex *in_buf = in_buf_data;
+            liquid_float_complex *out_buf = out_buf_data;
+            liquid_float_complex *temp_buf = NULL;
+
+            for (int i = 0; i < bufSize; i++) {
                 in_buf[i].real = (float) (*data)[i * 2] / 127.0f;
                 in_buf[i].imag = (float) (*data)[i * 2 + 1] / 127.0f;
             }
 
             if (shift_freq != 0) {
                 if (shift_freq < 0) {
-                    nco_crcf_mix_block_up(nco_shift, in_buf, out_buf, BUF_SIZE / 2);
+                    nco_crcf_mix_block_up(nco_shift, in_buf, out_buf, bufSize);
                 } else {
-                    nco_crcf_mix_block_down(nco_shift, in_buf, out_buf, BUF_SIZE / 2);
+                    nco_crcf_mix_block_down(nco_shift, in_buf, out_buf, bufSize);
                 }
                 temp_buf = in_buf;
                 in_buf = out_buf;
                 out_buf = temp_buf;
             }
 
-            firfilt_crcf_execute_block(fir_filter, in_buf, BUF_SIZE / 2, out_buf);
+            firfilt_crcf_execute_block(fir_filter, in_buf, bufSize, out_buf);
 
-            int out_size = ceil((float) (BUF_SIZE / 2) * resample_ratio);
+            int out_size = ceil((float) (bufSize) * resample_ratio);
 
-            liquid_float_complex resampled_output[out_size];
+            DemodulatorThreadPostIQData resamp;
-            float demod_output[out_size];
+
+            resamp.audio_resample_ratio = audio_resample_ratio;
+            resamp.audio_resampler = audio_resampler;
+            resamp.data.resize(out_size);
 
             unsigned int num_written;       // number of values written to buffer
-            msresamp_crcf_execute(resampler, out_buf, (BUF_SIZE / 2), resampled_output, &num_written);
+            msresamp_crcf_execute(resampler, out_buf, (bufSize), &resamp.data[0], &num_written);
 
-            freqdem_demodulate_block(fdem, resampled_output, num_written, demod_output);
+            resamp.data.resize(num_written);
 
-            for (int i = 0; i < num_written; i++) {
+            postInputQueue->push(resamp);
-                resampled_output[i].real = demod_output[i];
-                resampled_output[i].imag = 0;
-            }
-
-            int audio_out_size = ceil((float) (num_written) * audio_resample_ratio);
-            liquid_float_complex resampled_audio_output[audio_out_size];
-
-            unsigned int num_audio_written;
-            msresamp_crcf_execute(audio_resampler, resampled_output, num_written, resampled_audio_output, &num_audio_written);
-
-            std::vector<float> newBuffer;
-            newBuffer.resize(num_audio_written * 2);
-            for (int i = 0; i < num_audio_written; i++) {
-                liquid_float_complex y = resampled_audio_output[i];
-
-                newBuffer[i * 2] = y.real;
-                newBuffer[i * 2 + 1] = y.real;
-            }
-
-            AudioThreadInput ati;
-            ati.data = newBuffer;
-
-            if (audioInputQueue != NULL) {
-                audioInputQueue->push(ati);
-            }
-
-            if (visOutQueue != NULL) {
-                visOutQueue->push(ati);
-            }
         }
 
         if (!workerResults->empty()) {
@@ -244,16 +225,13 @@ void DemodulatorThread::threadMain() {
         }
     }
 
-    delete in_buf;
+    std::cout << "Demodulator preprocessor thread done." << std::endl;
-    delete out_buf;
+    DemodulatorThreadCommand tCmd(DemodulatorThreadCommand::DEMOD_THREAD_CMD_DEMOD_PREPROCESS_TERMINATED);
-
-    std::cout << "Demodulator thread done." << std::endl;
-    DemodulatorThreadCommand tCmd(DemodulatorThreadCommand::DEMOD_THREAD_CMD_DEMOD_TERMINATED);
     tCmd.context = this;
     threadQueueNotify->push(tCmd);
 }
 
-void DemodulatorThread::terminate() {
+void DemodulatorPreThread::terminate() {
     terminated = true;
     DemodulatorThreadIQData inp;    // push dummy to nudge queue
     inputQueue->push(inp);

src/demod/DemodulatorPreThread.h

@@ -2,46 +2,16 @@
 
 #include <queue>
 #include <vector>
-#include "wx/wxprec.h"
 
-#ifndef WX_PRECOMP
-#include "wx/wx.h"
-#endif
-
-#include "wx/thread.h"
-
-#include "liquid/liquid.h"
 #include "CubicSDRDefs.h"
-#include "DemodulatorWorkerThread.h"
 #include "DemodDefs.h"
+#include "DemodulatorWorkerThread.h"
 
-class DemodulatorThreadParameters {
+class DemodulatorPreThread {
-public:
-    unsigned int frequency;
-    unsigned int inputRate;
-    unsigned int bandwidth; // set equal to disable second stage re-sampling?
-    unsigned int audioSampleRate;
-
-    DemodulatorType demodType;
-
-    DemodulatorThreadParameters() :
-            frequency(0), inputRate(SRATE), bandwidth(200000), audioSampleRate(
-                    AUDIO_FREQUENCY), demodType(DEMOD_TYPE_FM) {
-
-    }
-
-    ~DemodulatorThreadParameters() {
-
-    }
-};
-
-typedef ThreadQueue<AudioThreadInput> DemodulatorThreadOutputQueue;
-
-class DemodulatorThread {
 public:
 
-	DemodulatorThread(DemodulatorThreadInputQueue* pQueue, DemodulatorThreadCommandQueue* threadQueueNotify);
+	DemodulatorPreThread(DemodulatorThreadInputQueue* pQueueIn, DemodulatorThreadPostInputQueue* pQueueOut, DemodulatorThreadCommandQueue* threadQueueNotify);
-	~DemodulatorThread();
+	~DemodulatorPreThread();
 
 #ifdef __APPLE__
 	void *threadMain();
@@ -49,10 +19,6 @@ public:
 	void threadMain();
 #endif
 
-	void setVisualOutputQueue(DemodulatorThreadOutputQueue *tQueue) {
-		visOutQueue = tQueue;
-	}
-
 	void setCommandQueue(DemodulatorThreadCommandQueue *tQueue) {
 		commandQueue = tQueue;
 	}
@@ -71,18 +37,17 @@ public:
 
 #ifdef __APPLE__
 	static void *pthread_helper(void *context) {
-		return ((DemodulatorThread *) context)->threadMain();
+		return ((DemodulatorPreThread *) context)->threadMain();
 	}
 #endif
 
 protected:
 	DemodulatorThreadInputQueue* inputQueue;
-	DemodulatorThreadOutputQueue* visOutQueue;
+	DemodulatorThreadPostInputQueue* postInputQueue;
 	DemodulatorThreadCommandQueue* commandQueue;
 	AudioThreadInputQueue *audioInputQueue;
 
 	firfilt_crcf fir_filter;
-
 	msresamp_crcf resampler;
 	float resample_ratio;