Deep redesign: phase #4. Compiles

plugins/samplesource/bladerf/bladerfgui.cpp

@@ -20,6 +20,7 @@
 #include "ui_bladerfgui.h"
 #include "plugin/pluginapi.h"
 #include "gui/colormapper.h"
+#include "dsp/dspengine.h"
 #include "bladerfgui.h"
 
 BladerfGui::BladerfGui(PluginAPI* pluginAPI, QWidget* parent) :
@@ -35,8 +36,8 @@ BladerfGui::BladerfGui(PluginAPI* pluginAPI, QWidget* parent) :
 	connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateHardware()));
 	displaySettings();
 
-	m_sampleSource = new BladerfInput(m_pluginAPI->getMainWindowMessageQueue());
-	m_pluginAPI->setSampleSource(m_sampleSource);
+	m_sampleSource = new BladerfInput();
+	DSPEngine::instance()->setSource(m_sampleSource);
 }
 
 BladerfGui::~BladerfGui()
@@ -61,32 +62,14 @@ QString BladerfGui::getName() const
 
 void BladerfGui::resetToDefaults()
 {
-	m_generalSettings.resetToDefaults();
 	m_settings.resetToDefaults();
 	displaySettings();
 	sendSettings();
 }
 
-QByteArray BladerfGui::serializeGeneral() const
-{
-	return m_generalSettings.serialize();
-}
-
-bool BladerfGui::deserializeGeneral(const QByteArray&data)
-{
-	if(m_generalSettings.deserialize(data)) {
-		displaySettings();
-		sendSettings();
-		return true;
-	} else {
-		resetToDefaults();
-		return false;
-	}
-}
-
 qint64 BladerfGui::getCenterFrequency() const
 {
-	return m_generalSettings.m_centerFrequency;
+	return m_settings.m_centerFrequency;
 }
 
 QByteArray BladerfGui::serialize() const
@@ -106,23 +89,25 @@ bool BladerfGui::deserialize(const QByteArray& data)
 	}
 }
 
-bool BladerfGui::handleMessage(Message* message)
+bool BladerfGui::handleMessage(const Message& message)
 {
-	if(BladerfInput::MsgReportBladerf::match(message)) {
+	if (BladerfInput::MsgReportBladerf::match(message))
+	{
 		displaySettings();
-		message->completed();
 		return true;
-	} else {
+	}
+	else
+	{
 		return false;
 	}
 }
 
 void BladerfGui::displaySettings()
 {
-	ui->centerFrequency->setValue(m_generalSettings.m_centerFrequency / 1000);
+	ui->centerFrequency->setValue(m_settings.m_centerFrequency / 1000);
 
-	ui->samplerateText->setText(tr("%1k").arg(m_settings.m_samplerate / 1000));
-	unsigned int sampleRateIndex = BladerfSampleRates::getRateIndex(m_settings.m_samplerate);
+	ui->samplerateText->setText(tr("%1k").arg(m_settings.m_devSampleRate / 1000));
+	unsigned int sampleRateIndex = BladerfSampleRates::getRateIndex(m_settings.m_devSampleRate);
 	ui->samplerate->setValue(sampleRateIndex);
 
 	ui->bandwidthText->setText(tr("%1k").arg(m_settings.m_bandwidth / 1000));
@@ -154,7 +139,7 @@ void BladerfGui::sendSettings()
 
 void BladerfGui::on_centerFrequency_changed(quint64 value)
 {
-	m_generalSettings.m_centerFrequency = value * 1000;
+	m_settings.m_centerFrequency = value * 1000;
 	sendSettings();
 }
 
@@ -162,7 +147,7 @@ void BladerfGui::on_samplerate_valueChanged(int value)
 {
 	int newrate = BladerfSampleRates::getRate(value);
 	ui->samplerateText->setText(tr("%1k").arg(newrate));
-	m_settings.m_samplerate = newrate * 1000;
+	m_settings.m_devSampleRate = newrate * 1000;
 	sendSettings();
 }
 
@@ -291,8 +276,8 @@ void BladerfGui::on_xb200_currentIndexChanged(int index)
 
 void BladerfGui::updateHardware()
 {
-	BladerfInput::MsgConfigureBladerf* message = BladerfInput::MsgConfigureBladerf::create(m_generalSettings, m_settings);
-	message->submit(m_pluginAPI->getDSPEngineMessageQueue());
+	BladerfInput::MsgConfigureBladerf* message = BladerfInput::MsgConfigureBladerf::create( m_settings);
+	m_sampleSource->getInputMessageQueue()->push(message);
 	m_updateTimer.stop();
 }
 

plugins/samplesource/bladerf/bladerfgui.h

@@ -34,25 +34,22 @@ class BladerfGui : public QWidget, public PluginGUI {
 
 public:
 	explicit BladerfGui(PluginAPI* pluginAPI, QWidget* parent = NULL);
-	~BladerfGui();
+	virtual ~BladerfGui();
 	void destroy();
 
 	void setName(const QString& name);
 	QString getName() const;
 
 	void resetToDefaults();
-	QByteArray serializeGeneral() const;
-	bool deserializeGeneral(const QByteArray&data);
 	qint64 getCenterFrequency() const;
 	QByteArray serialize() const;
 	bool deserialize(const QByteArray& data);
-	bool handleMessage(Message* message);
+	virtual bool handleMessage(const Message& message);
 
 private:
 	Ui::BladerfGui* ui;
 
 	PluginAPI* m_pluginAPI;
-	SampleSource::GeneralSettings m_generalSettings;
 	BladerfInput::Settings m_settings;
 	QTimer m_updateTimer;
 	std::vector<int> m_gains;

plugins/samplesource/bladerf/bladerfinput.cpp

@@ -29,10 +29,11 @@ MESSAGE_CLASS_DEFINITION(BladerfInput::MsgConfigureBladerf, Message)
 MESSAGE_CLASS_DEFINITION(BladerfInput::MsgReportBladerf, Message)
 
 BladerfInput::Settings::Settings() :
+	m_centerFrequency(435000*1000),
+	m_devSampleRate(3072000),
 	m_lnaGain(0),
 	m_vga1(20),
 	m_vga2(9),
-	m_samplerate(3072000),
 	m_bandwidth(1500000),
 	m_log2Decim(0),
 	m_fcPos(FC_POS_INFRA),
@@ -44,10 +45,11 @@ BladerfInput::Settings::Settings() :
 
 void BladerfInput::Settings::resetToDefaults()
 {
+	m_centerFrequency = 435000*1000;
+	m_devSampleRate = 3072000;
 	m_lnaGain = 0;
 	m_vga1 = 20;
 	m_vga2 = 9;
-	m_samplerate = 3072000;
 	m_bandwidth = 1500000;
 	m_log2Decim = 0;
 	m_fcPos = FC_POS_INFRA;
@@ -59,16 +61,17 @@ void BladerfInput::Settings::resetToDefaults()
 QByteArray BladerfInput::Settings::serialize() const
 {
 	SimpleSerializer s(1);
-	s.writeS32(1, m_lnaGain);
-	s.writeS32(2, m_vga1);
-	s.writeS32(3, m_vga2);
-	s.writeS32(4, m_samplerate);
-	s.writeU32(5, m_log2Decim);
-	s.writeBool(6, m_xb200);
-	s.writeS32(7, (int) m_xb200Path);
-	s.writeS32(8, (int) m_xb200Filter);
-	s.writeS32(9, m_bandwidth);
-	s.writeS32(10, (int) m_fcPos);
+	s.writeU64(1, m_centerFrequency);
+	s.writeS32(2, m_devSampleRate);
+	s.writeS32(3, m_lnaGain);
+	s.writeS32(4, m_vga1);
+	s.writeS32(5, m_vga2);
+	s.writeU32(6, m_log2Decim);
+	s.writeBool(7, m_xb200);
+	s.writeS32(8, (int) m_xb200Path);
+	s.writeS32(9, (int) m_xb200Filter);
+	s.writeS32(10, m_bandwidth);
+	s.writeS32(11, (int) m_fcPos);
 	return s.final();
 }
 
@@ -76,63 +79,75 @@ bool BladerfInput::Settings::deserialize(const QByteArray& data)
 {
 	SimpleDeserializer d(data);
 
-	if(!d.isValid()) {
+	if (!d.isValid())
+	{
 		resetToDefaults();
 		return false;
 	}
 
-	if(d.getVersion() == 1) {
+	if (d.getVersion() == 1)
+	{
 		int intval;
-		d.readS32(1, &m_lnaGain, 0);
-		d.readS32(2, &m_vga1, 20);
-		d.readS32(3, &m_vga2, 9);
-		d.readS32(4, &m_samplerate, 0);
-		d.readU32(5, &m_log2Decim, 0);
-		d.readBool(6, &m_xb200);
-		d.readS32(7, &intval);
-		m_xb200Path = (bladerf_xb200_path) intval;
+		d.readU64(1, &m_centerFrequency, 435000*1000);
+		d.readS32(2, &m_devSampleRate, 3072000);
+		d.readS32(3, &m_lnaGain, 0);
+		d.readS32(4, &m_vga1, 20);
+		d.readS32(5, &m_vga2, 9);
+		d.readU32(6, &m_log2Decim, 0);
+		d.readBool(7, &m_xb200);
 		d.readS32(8, &intval);
+		m_xb200Path = (bladerf_xb200_path) intval;
+		d.readS32(9, &intval);
 		m_xb200Filter = (bladerf_xb200_filter) intval;
-		d.readS32(9, &m_bandwidth, 0);
-		d.readS32(10, &intval, 0);
+		d.readS32(10, &m_bandwidth, 0);
+		d.readS32(11, &intval, 0);
 		m_fcPos = (fcPos_t) intval;
 		return true;
-	} else {
+	}
+	else
+	{
 		resetToDefaults();
 		return false;
 	}
 }
 
-BladerfInput::BladerfInput(MessageQueue* msgQueueToGUI) :
-	SampleSource(msgQueueToGUI),
+BladerfInput::BladerfInput() :
 	m_settings(),
-	m_dev(NULL),
-	m_bladerfThread(NULL),
+	m_dev(0),
+	m_bladerfThread(0),
 	m_deviceDescription("BladeRF")
 {
 }
 
 BladerfInput::~BladerfInput()
 {
-	stopInput();
+	stop();
 }
 
-bool BladerfInput::startInput(int device)
+bool BladerfInput::init(const Message& cmd)
+{
+	return false;
+}
+
+bool BladerfInput::start(int device)
 {
 	QMutexLocker mutexLocker(&m_mutex);
 
-	if(m_dev != NULL)
-		stopInput();
+	if (m_dev != 0)
+	{
+		stop();
+	}
 
 	int res;
 	int fpga_loaded;
 
-	if(!m_sampleFifo.setSize(96000 * 4)) {
+	if (!m_sampleFifo.setSize(96000 * 4))
+	{
 		qCritical("Could not allocate SampleFifo");
 		return false;
 	}
 
-	if ((m_dev = open_bladerf_from_serial(0)) == NULL) // TODO: fix; Open first available device as there is no proper handling for multiple devices
+	if ((m_dev = open_bladerf_from_serial(0)) == 0) // TODO: fix; Open first available device as there is no proper handling for multiple devices
 	{
 		qCritical("could not open BladeRF");
 		return false;
@@ -140,11 +155,14 @@ bool BladerfInput::startInput(int device)
 
     fpga_loaded = bladerf_is_fpga_configured(m_dev);
 
-    if (fpga_loaded < 0) {
+    if (fpga_loaded < 0)
+    {
     	qCritical("Failed to check FPGA state: %s",
                   bladerf_strerror(fpga_loaded));
     	return false;
-    } else if (fpga_loaded == 0) {
+    }
+    else if (fpga_loaded == 0)
+    {
     	qCritical("The device's FPGA is not loaded.");
     	return false;
     }
@@ -170,31 +188,34 @@ bool BladerfInput::startInput(int device)
 	m_bladerfThread->startWork();
 
 	mutexLocker.unlock();
-	applySettings(m_generalSettings, m_settings, true);
+	applySettings(m_settings, true);
 
 	qDebug("BladerfInput::startInput: started");
-	//MsgReportBladerf::create(m_gains)->submit(m_guiMessageQueue); Pass anything here
 
 	return true;
 
 failed:
-	stopInput();
+	stop();
 	return false;
 }
 
-void BladerfInput::stopInput()
+void BladerfInput::stop()
 {
 	QMutexLocker mutexLocker(&m_mutex);
 
-	if(m_bladerfThread != NULL) {
+	if(m_bladerfThread != 0)
+	{
 		m_bladerfThread->stopWork();
 		delete m_bladerfThread;
-		m_bladerfThread = NULL;
+		m_bladerfThread = 0;
 	}
-	if(m_dev != NULL) {
+
+	if(m_dev != 0)
+	{
 		bladerf_close(m_dev);
-		m_dev = NULL;
+		m_dev = 0;
 	}
+
 	m_deviceDescription.clear();
 }
 
@@ -205,28 +226,28 @@ const QString& BladerfInput::getDeviceDescription() const
 
 int BladerfInput::getSampleRate() const
 {
-	int rate = m_settings.m_samplerate;
+	int rate = m_settings.m_devSampleRate;
 	return (rate / (1<<m_settings.m_log2Decim));
 }
 
 quint64 BladerfInput::getCenterFrequency() const
 {
-	return m_generalSettings.m_centerFrequency;
+	return m_settings.m_centerFrequency;
 }
 
-bool BladerfInput::handleMessage(Message* message)
+bool BladerfInput::handleMessage(const Message& message)
 {
 	if (MsgConfigureBladerf::match(message))
 	{
 		qDebug() << "BladerfInput::handleMessage: MsgConfigureBladerf";
 
-		MsgConfigureBladerf* conf = (MsgConfigureBladerf*) message;
+		MsgConfigureBladerf& conf = (MsgConfigureBladerf&) message;
 
-		if(!applySettings(conf->getGeneralSettings(), conf->getSettings(), false)) {
+		if (!applySettings(conf.getSettings(), false))
+		{
 			qDebug("BladeRF config error");
 		}
 
-		message->completed();
 		return true;
 	}
 	else
@@ -235,7 +256,7 @@ bool BladerfInput::handleMessage(Message* message)
 	}
 }
 
-bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const Settings& settings, bool force)
+bool BladerfInput::applySettings(const Settings& settings, bool force)
 {
 	QMutexLocker mutexLocker(&m_mutex);
 
@@ -245,11 +266,14 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		m_settings.m_lnaGain = settings.m_lnaGain;
 
-		if (m_dev != NULL)
+		if (m_dev != 0)
 		{
-			if(bladerf_set_lna_gain(m_dev, getLnaGain(m_settings.m_lnaGain)) != 0) {
+			if(bladerf_set_lna_gain(m_dev, getLnaGain(m_settings.m_lnaGain)) != 0)
+			{
 				qDebug("bladerf_set_lna_gain() failed");
-			} else {
+			}
+			else
+			{
 				qDebug() << "BladerfInput: LNA gain set to " << getLnaGain(m_settings.m_lnaGain);
 			}
 		}
@@ -259,11 +283,14 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		m_settings.m_vga1 = settings.m_vga1;
 
-		if (m_dev != NULL)
+		if (m_dev != 0)
 		{
-			if(bladerf_set_rxvga1(m_dev, m_settings.m_vga1) != 0) {
+			if(bladerf_set_rxvga1(m_dev, m_settings.m_vga1) != 0)
+			{
 				qDebug("bladerf_set_rxvga1() failed");
-			} else {
+			}
+			else
+			{
 				qDebug() << "BladerfInput: VGA1 gain set to " << m_settings.m_vga1;
 			}
 		}
@@ -273,11 +300,14 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		m_settings.m_vga2 = settings.m_vga2;
 
-		if(m_dev != NULL)
+		if(m_dev != 0)
 		{
-			if(bladerf_set_rxvga2(m_dev, m_settings.m_vga2) != 0) {
+			if(bladerf_set_rxvga2(m_dev, m_settings.m_vga2) != 0)
+			{
 				qDebug("bladerf_set_rxvga2() failed");
-			} else {
+			}
+			else
+			{
 				qDebug() << "BladerfInput: VGA2 gain set to " << m_settings.m_vga2;
 			}
 		}
@@ -287,21 +317,27 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		m_settings.m_xb200 = settings.m_xb200;
 
-		if (m_dev != NULL)
+		if (m_dev != 0)
 		{
 			if (m_settings.m_xb200)
 			{
-				if (bladerf_expansion_attach(m_dev, BLADERF_XB_200) != 0) {
+				if (bladerf_expansion_attach(m_dev, BLADERF_XB_200) != 0)
+				{
 					qDebug("bladerf_expansion_attach(xb200) failed");
-				} else {
+				}
+				else
+				{
 					qDebug() << "BladerfInput: Attach XB200";
 				}
 			}
 			else
 			{
-				if (bladerf_expansion_attach(m_dev, BLADERF_XB_NONE) != 0) {
+				if (bladerf_expansion_attach(m_dev, BLADERF_XB_NONE) != 0)
+				{
 					qDebug("bladerf_expansion_attach(none) failed");
-				} else {
+				}
+				else
+				{
 					qDebug() << "BladerfInput: Detach XB200";
 				}
 			}
@@ -311,11 +347,15 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	if ((m_settings.m_xb200Path != settings.m_xb200Path) || force)
 	{
 		m_settings.m_xb200Path = settings.m_xb200Path;
-		if (m_dev != NULL)
+
+		if (m_dev != 0)
 		{
-			if(bladerf_xb200_set_path(m_dev, BLADERF_MODULE_RX, m_settings.m_xb200Path) != 0) {
+			if(bladerf_xb200_set_path(m_dev, BLADERF_MODULE_RX, m_settings.m_xb200Path) != 0)
+			{
 				qDebug("bladerf_xb200_set_path(BLADERF_MODULE_RX) failed");
-			} else {
+			}
+			else
+			{
 				qDebug() << "BladerfInput: set xb200 path to " << m_settings.m_xb200Path;
 			}
 		}
@@ -325,32 +365,35 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		m_settings.m_xb200Filter = settings.m_xb200Filter;
 
-		if(m_dev != NULL)
+		if (m_dev != 0)
 		{
-			if(bladerf_xb200_set_filterbank(m_dev, BLADERF_MODULE_RX, m_settings.m_xb200Filter) != 0) {
+			if(bladerf_xb200_set_filterbank(m_dev, BLADERF_MODULE_RX, m_settings.m_xb200Filter) != 0)
+			{
 				qDebug("bladerf_xb200_set_filterbank(BLADERF_MODULE_RX) failed");
-			} else {
+			}
+			else
+			{
 				qDebug() << "BladerfInput: set xb200 filter to " << m_settings.m_xb200Filter;
 			}
 		}
 	}
 
-	if ((m_settings.m_samplerate != settings.m_samplerate) || force)
+	if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || force)
 	{
-		m_settings.m_samplerate = settings.m_samplerate;
+		m_settings.m_devSampleRate = settings.m_devSampleRate;
 
-		if (m_dev != NULL)
+		if (m_dev != 0)
 		{
 			unsigned int actualSamplerate;
 
-			if (bladerf_set_sample_rate(m_dev, BLADERF_MODULE_RX, m_settings.m_samplerate, &actualSamplerate) < 0)
+			if (bladerf_set_sample_rate(m_dev, BLADERF_MODULE_RX, m_settings.m_devSampleRate, &actualSamplerate) < 0)
 			{
-				qCritical("could not set sample rate: %d", m_settings.m_samplerate);
+				qCritical("could not set sample rate: %d", m_settings.m_devSampleRate);
 			}
 			else
 			{
 				qDebug() << "bladerf_set_sample_rate(BLADERF_MODULE_RX) actual sample rate is " << actualSamplerate;
-				m_bladerfThread->setSamplerate(m_settings.m_samplerate);
+				m_bladerfThread->setSamplerate(m_settings.m_devSampleRate);
 			}
 		}
 	}
@@ -359,13 +402,16 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		m_settings.m_bandwidth = settings.m_bandwidth;
 
-		if(m_dev != NULL)
+		if(m_dev != 0)
 		{
 			unsigned int actualBandwidth;
 
 			if( bladerf_set_bandwidth(m_dev, BLADERF_MODULE_RX, m_settings.m_bandwidth, &actualBandwidth) < 0)
-				qCritical("could not set sample rate: %d", m_settings.m_samplerate);
-			else {
+			{
+				qCritical("could not set bandwidth: %d", m_settings.m_bandwidth);
+			}
+			else
+			{
 				qDebug() << "bladerf_set_bandwidth(BLADERF_MODULE_RX) actual bandwidth is " << actualBandwidth;
 			}
 		}
@@ -375,7 +421,7 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		m_settings.m_log2Decim = settings.m_log2Decim;
 
-		if(m_dev != NULL)
+		if(m_dev != 0)
 		{
 			m_bladerfThread->setLog2Decimation(m_settings.m_log2Decim);
 			qDebug() << "BladerfInput: set decimation to " << (1<<m_settings.m_log2Decim);
@@ -386,22 +432,22 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		m_settings.m_fcPos = settings.m_fcPos;
 
-		if(m_dev != NULL)
+		if(m_dev != 0)
 		{
 			m_bladerfThread->setFcPos((int) m_settings.m_fcPos);
 			qDebug() << "BladerfInput: set fc pos (enum) to " << (int) m_settings.m_fcPos;
 		}
 	}
 
-	m_generalSettings.m_centerFrequency = generalSettings.m_centerFrequency;
+	m_settings.m_centerFrequency = settings.m_centerFrequency;
 
-	qint64 centerFrequency = m_generalSettings.m_centerFrequency;
+	qint64 centerFrequency = m_settings.m_centerFrequency;
 	qint64 f_img = centerFrequency;
 	qint64 f_cut = centerFrequency + m_settings.m_bandwidth/2;
 
 	if ((m_settings.m_log2Decim == 0) || (m_settings.m_fcPos == FC_POS_CENTER))
 	{
-		centerFrequency = m_generalSettings.m_centerFrequency;
+		centerFrequency = m_settings.m_centerFrequency;
 		f_img = centerFrequency;
 		f_cut = centerFrequency + m_settings.m_bandwidth/2;
 	}
@@ -409,29 +455,30 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 	{
 		if (m_settings.m_fcPos == FC_POS_INFRA)
 		{
-			centerFrequency = m_generalSettings.m_centerFrequency + (m_settings.m_samplerate / 4);
-			f_img = centerFrequency + m_settings.m_samplerate/2;
+			centerFrequency = m_settings.m_centerFrequency + (m_settings.m_devSampleRate / 4);
+			f_img = centerFrequency + m_settings.m_devSampleRate/2;
 			f_cut = centerFrequency + m_settings.m_bandwidth/2;
 		}
 		else if (m_settings.m_fcPos == FC_POS_SUPRA)
 		{
-			centerFrequency = m_generalSettings.m_centerFrequency - (m_settings.m_samplerate / 4);
-			f_img = centerFrequency - m_settings.m_samplerate/2;
+			centerFrequency = m_settings.m_centerFrequency - (m_settings.m_devSampleRate / 4);
+			f_img = centerFrequency - m_settings.m_devSampleRate/2;
 			f_cut = centerFrequency - m_settings.m_bandwidth/2;
 		}
 	}
 
 	if (m_dev != NULL)
 	{
-		if (bladerf_set_frequency( m_dev, BLADERF_MODULE_RX, centerFrequency ) != 0) {
-			qDebug("bladerf_set_frequency(%lld) failed", m_generalSettings.m_centerFrequency);
+		if (bladerf_set_frequency( m_dev, BLADERF_MODULE_RX, centerFrequency ) != 0)
+		{
+			qDebug("bladerf_set_frequency(%lld) failed", m_settings.m_centerFrequency);
 		}
 	}
 
-	qDebug() << "  - center freq: " << m_generalSettings.m_centerFrequency << " Hz"
+	qDebug() << "  - center freq: " << m_settings.m_centerFrequency << " Hz"
 			<< " RF center freq: " << centerFrequency << " Hz"
-			<< " RF sample rate: " << m_settings.m_samplerate << "Hz"
-			<< " Actual sample rate: " << m_settings.m_samplerate/(1<<m_settings.m_log2Decim) << "Hz"
+			<< " RF sample rate: " << m_settings.m_devSampleRate << "Hz"
+			<< " Actual sample rate: " << m_settings.m_devSampleRate/(1<<m_settings.m_log2Decim) << "Hz"
 			<< " BW: " << m_settings.m_bandwidth << "Hz"
 			<< " img: " << f_img << "Hz"
 			<< " cut: " << f_cut << "Hz"
@@ -442,11 +489,16 @@ bool BladerfInput::applySettings(const GeneralSettings& generalSettings, const S
 
 bladerf_lna_gain BladerfInput::getLnaGain(int lnaGain)
 {
-	if (lnaGain == 2) {
+	if (lnaGain == 2)
+	{
 		return BLADERF_LNA_GAIN_MAX;
-	} else if (lnaGain == 1) {
+	}
+	else if (lnaGain == 1)
+	{
 		return BLADERF_LNA_GAIN_MID;
-	} else {
+	}
+	else
+	{
 		return BLADERF_LNA_GAIN_BYPASS;
 	}
 }
@@ -465,21 +517,27 @@ struct bladerf *BladerfInput::open_bladerf_from_serial(const char *serial)
 
     /* Specify the desired device's serial number, while leaving all other
      * fields in the info structure wildcard values */
-    if (serial != NULL) {
+    if (serial != NULL)
+    {
 		strncpy(info.serial, serial, BLADERF_SERIAL_LENGTH - 1);
 		info.serial[BLADERF_SERIAL_LENGTH - 1] = '\0';
     }
 
     status = bladerf_open_with_devinfo(&dev, &info);
 
-    if (status == BLADERF_ERR_NODEV) {
+    if (status == BLADERF_ERR_NODEV)
+    {
         fprintf(stderr, "No devices available with serial=%s\n", serial);
         return NULL;
-    } else if (status != 0) {
+    }
+    else if (status != 0)
+    {
         fprintf(stderr, "Failed to open device with serial=%s (%s)\n",
                 serial, bladerf_strerror(status));
         return NULL;
-    } else {
+    }
+    else
+    {
         return dev;
     }
 }

plugins/samplesource/bladerf/bladerfinput.h

@@ -32,10 +32,11 @@ public:
 	} fcPos_t;
 
 	struct Settings {
+		quint64 m_centerFrequency;
+		qint32 m_devSampleRate;
 		qint32 m_lnaGain;
 		qint32 m_vga1;
 		qint32 m_vga2;
-		qint32 m_samplerate;
 		qint32 m_bandwidth;
 		quint32 m_log2Decim;
 		fcPos_t m_fcPos;
@@ -53,21 +54,18 @@ public:
 		MESSAGE_CLASS_DECLARATION
 
 	public:
-		const GeneralSettings& getGeneralSettings() const { return m_generalSettings; }
 		const Settings& getSettings() const { return m_settings; }
 
-		static MsgConfigureBladerf* create(const GeneralSettings& generalSettings, const Settings& settings)
+		static MsgConfigureBladerf* create(const Settings& settings)
 		{
-			return new MsgConfigureBladerf(generalSettings, settings);
+			return new MsgConfigureBladerf(settings);
 		}
 
 	private:
-		GeneralSettings m_generalSettings;
 		Settings m_settings;
 
-		MsgConfigureBladerf(const GeneralSettings& generalSettings, const Settings& settings) :
+		MsgConfigureBladerf(const Settings& settings) :
 			Message(),
-			m_generalSettings(generalSettings),
 			m_settings(settings)
 		{ }
 	};
@@ -89,28 +87,29 @@ public:
 		{ }
 	};
 
-	BladerfInput(MessageQueue* msgQueueToGUI);
-	~BladerfInput();
+	BladerfInput();
+	virtual ~BladerfInput();
 
-	bool startInput(int device);
-	void stopInput();
+	virtual bool init(const Message& message);
+	virtual bool start(int device);
+	virtual void stop();
 
-	const QString& getDeviceDescription() const;
-	int getSampleRate() const;
-	quint64 getCenterFrequency() const;
+	virtual const QString& getDeviceDescription() const;
+	virtual int getSampleRate() const;
+	virtual quint64 getCenterFrequency() const;
 
-	bool handleMessage(Message* message);
+	virtual bool handleMessage(const Message& message);
 
 private:
+	bool applySettings(const Settings& settings, bool force);
+	bladerf_lna_gain getLnaGain(int lnaGain);
+	struct bladerf *open_bladerf_from_serial(const char *serial);
+
 	QMutex m_mutex;
 	Settings m_settings;
 	struct bladerf* m_dev;
 	BladerfThread* m_bladerfThread;
 	QString m_deviceDescription;
-
-	bool applySettings(const GeneralSettings& generalSettings, const Settings& settings, bool force);
-	bladerf_lna_gain getLnaGain(int lnaGain);
-	struct bladerf *open_bladerf_from_serial(const char *serial);
 };
 
 #endif // INCLUDE_BLADERFINPUT_H

plugins/samplesource/fcd/CMakeLists.txt

@@ -5,7 +5,6 @@ set(fcd_SOURCES
 	fcdinput.cpp
 	fcdplugin.cpp
 	fcdthread.cpp
-	fcdsource.cpp
 	hid-libusb.c
 )
 

plugins/samplesource/fcd/fcdgui.cpp

@@ -1,6 +1,7 @@
 #include "fcdgui.h"
 #include "ui_fcdgui.h"
 #include "plugin/pluginapi.h"
+#include "dsp/dspengine.h"
 
 FCDGui::FCDGui(PluginAPI* pluginAPI, QWidget* parent) :
 	QWidget(parent),
@@ -14,8 +15,8 @@ FCDGui::FCDGui(PluginAPI* pluginAPI, QWidget* parent) :
 	connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateHardware()));
 	displaySettings();
 
-	m_sampleSource = new FCDInput(m_pluginAPI->getMainWindowMessageQueue());
-	m_pluginAPI->setSampleSource(m_sampleSource);
+	m_sampleSource = new FCDInput();
+	DSPEngine::instance()->setSource(m_sampleSource);
 }
 
 FCDGui::~FCDGui()
@@ -40,34 +41,11 @@ QString FCDGui::getName() const
 
 void FCDGui::resetToDefaults()
 {
-	m_generalSettings.resetToDefaults();
 	m_settings.resetToDefaults();
 	displaySettings();
 	sendSettings();
 }
 
-QByteArray FCDGui::serializeGeneral() const
-{
-	return m_generalSettings.serialize();
-}
-
-bool FCDGui::deserializeGeneral(const QByteArray&data)
-{
-	if(m_generalSettings.deserialize(data)) {
-		displaySettings();
-		sendSettings();
-		return true;
-	} else {
-		resetToDefaults();
-		return false;
-	}
-}
-
-qint64 FCDGui::getCenterFrequency() const
-{
-	return m_generalSettings.m_centerFrequency;
-}
-
 QByteArray FCDGui::serialize() const
 {
 	return m_settings.serialize();
@@ -75,24 +53,27 @@ QByteArray FCDGui::serialize() const
 
 bool FCDGui::deserialize(const QByteArray& data)
 {
-	if(m_settings.deserialize(data)) {
+	if(m_settings.deserialize(data))
+	{
 		displaySettings();
 		sendSettings();
 		return true;
-	} else {
+	}
+	else
+	{
 		resetToDefaults();
 		return false;
 	}
 }
 
-bool FCDGui::handleMessage(Message* message)
+bool FCDGui::handleMessage(const Message& message)
 {
-	return true;
+	return false;
 }
 
 void FCDGui::displaySettings()
 {
-	ui->centerFrequency->setValue(m_generalSettings.m_centerFrequency / 1000);
+	ui->centerFrequency->setValue(m_settings.centerFrequency / 1000);
 	ui->checkBoxR->setChecked(m_settings.range);
 	ui->checkBoxG->setChecked(m_settings.gain);
 	ui->checkBoxB->setChecked(m_settings.bias);
@@ -106,49 +87,61 @@ void FCDGui::sendSettings()
 
 void FCDGui::on_centerFrequency_changed(quint64 value)
 {
-	m_generalSettings.m_centerFrequency = value * 1000;
+	m_settings.centerFrequency = value * 1000;
 	sendSettings();
 }
 
 void FCDGui::updateHardware()
 {
-	FCDInput::MsgConfigureFCD* message = FCDInput::MsgConfigureFCD::create(m_generalSettings, m_settings);
-	message->submit(m_pluginAPI->getDSPEngineMessageQueue());
+	FCDInput::MsgConfigureFCD* message = FCDInput::MsgConfigureFCD::create(m_settings);
+	m_sampleSource->getInputMessageQueue()->push(message);
 	m_updateTimer.stop();
 }
 
 void FCDGui::on_checkBoxR_stateChanged(int state)
 {
-	if (state == Qt::Checked) {
+	if (state == Qt::Checked)
+	{
 		ui->centerFrequency->setValueRange(7, 150U, 240000U);
 		ui->centerFrequency->setValue(7000);
-		m_generalSettings.m_centerFrequency = 7000 * 1000;
+		m_settings.centerFrequency = 7000 * 1000;
 		m_settings.range = 1;
 	}
-	else {
+	else
+	{
 		ui->centerFrequency->setValueRange(7, 420000U, 1900000U);
-		ui->centerFrequency->setValue(434450);
-		m_generalSettings.m_centerFrequency = 434450 * 1000;
+		ui->centerFrequency->setValue(435000);
+		m_settings.centerFrequency = 435000 * 1000;
 		m_settings.range = 0;
 	}
+
 	sendSettings();
 }
 
 void FCDGui::on_checkBoxG_stateChanged(int state)
 {
-	if (state == Qt::Checked) {
+	if (state == Qt::Checked)
+	{
 		m_settings.gain = 1;
-	} else {
+	}
+	else
+	{
 		m_settings.gain = 0;
 	}
+
 	sendSettings();
 }
+
 void FCDGui::on_checkBoxB_stateChanged(int state)
 {
-	if (state == Qt::Checked) {
+	if (state == Qt::Checked)
+	{
 		m_settings.bias = 1;
-	} else {
+	}
+	else
+	{
 		m_settings.bias = 0;
 	}
+
 	sendSettings();
 }

plugins/samplesource/fcd/fcdgui.h

@@ -16,25 +16,22 @@ class FCDGui : public QWidget, public PluginGUI {
 
 public:
 	explicit FCDGui(PluginAPI* pluginAPI, QWidget* parent = NULL);
-	~FCDGui();
+	virtual ~FCDGui();
 	void destroy();
 
 	void setName(const QString& name);
 	QString getName() const;
 
 	void resetToDefaults();
-	QByteArray serializeGeneral() const;
-	bool deserializeGeneral(const QByteArray&data);
-	qint64 getCenterFrequency() const;
 	QByteArray serialize() const;
 	bool deserialize(const QByteArray& data);
-	bool handleMessage(Message* message);
+
+	virtual bool handleMessage(const Message& message);
 
 private:
 	Ui::FCDGui* ui;
 
 	PluginAPI* m_pluginAPI;
-	SampleSource::GeneralSettings m_generalSettings;
 	FCDInput::Settings m_settings;
 	QTimer m_updateTimer;
 	std::vector<int> m_gains;

plugins/samplesource/fcd/fcdinput.cpp

@@ -20,12 +20,14 @@
 #include "fcdinput.h"
 #include "fcdthread.h"
 #include "fcdgui.h"
+#include "qthid.h"
 #include "util/simpleserializer.h"
 
 MESSAGE_CLASS_DEFINITION(FCDInput::MsgConfigureFCD, Message)
 //MESSAGE_CLASS_DEFINITION(FCDInput::MsgReportFCD, Message)
 
 FCDInput::Settings::Settings() :
+	centerFrequency(435000000),
 	range(0),
 	gain(0),
 	bias(0)
@@ -34,6 +36,7 @@ FCDInput::Settings::Settings() :
 
 void FCDInput::Settings::resetToDefaults()
 {
+	centerFrequency = 435000000;
 	range = 0;
 	gain = 0;
 	bias = 0;
@@ -42,75 +45,92 @@ void FCDInput::Settings::resetToDefaults()
 QByteArray FCDInput::Settings::serialize() const
 {
 	SimpleSerializer s(1);
-	s.writeS32(1, range);
-	s.writeS32(2, gain);
-	s.writeS32(3, bias);
+	s.writeU64(1, centerFrequency);
+	s.writeS32(2, range);
+	s.writeS32(3, gain);
+	s.writeS32(4, bias);
 	return s.final();
 }
 
 bool FCDInput::Settings::deserialize(const QByteArray& data)
 {
 	SimpleDeserializer d(data);
-	if(d.isValid() && d.getVersion() == 1) {
-                d.readS32(1, &range, 0);
-		d.readS32(2, &gain, 0);
-		d.readS32(3, &bias, 0);
+
+	if (d.isValid() && d.getVersion() == 1)
+	{
+		d.readU64(1, &centerFrequency, 435000000);
+        d.readS32(2, &range, 0);
+		d.readS32(3, &gain, 0);
+		d.readS32(4, &bias, 0);
 		return true;
 	}
+
 	resetToDefaults();
 	return true;
 }
 
-FCDInput::FCDInput(MessageQueue* msgQueueToGUI) :
-	SampleSource(msgQueueToGUI),
+FCDInput::FCDInput() :
 	m_settings(),
-	m_FCDThread(NULL),
+	m_FCDThread(0),
 	m_deviceDescription()
 {
 }
 
 FCDInput::~FCDInput()
 {
-	stopInput();
+	stop();
 }
 
-bool FCDInput::startInput(int device)
+bool FCDInput::init(const Message& cmd)
+{
+	return false;
+}
+
+bool FCDInput::start(int device)
 {
 	QMutexLocker mutexLocker(&m_mutex);
 
-	if(m_FCDThread)
+	if (m_FCDThread)
+	{
 		return false;
+	}
+
 	/* Apply settings before streaming to avoid bus contention;
 	 * there is very little spare bandwidth on a full speed USB device.
 	 * Failure is harmless if no device is found */
-	applySettings(m_generalSettings, m_settings, true);
 
-	if(!m_sampleFifo.setSize(4096*16)) {
+	applySettings(m_settings, true);
+
+	if(!m_sampleFifo.setSize(4096*16))
+	{
 		qCritical("Could not allocate SampleFifo");
 		return false;
 	}
 
-	if((m_FCDThread = new FCDThread(&m_sampleFifo)) == NULL) {
+	if ((m_FCDThread = new FCDThread(&m_sampleFifo)) == NULL)
+	{
 		qFatal("out of memory");
 		return false;
 	}
 
 	m_deviceDescription = QString("Funcube Dongle");
 
-	qDebug("FCDInput: start");
+	qDebug("FCDInput::start");
 	return true;
 }
 
-void FCDInput::stopInput()
+void FCDInput::stop()
 {
 	QMutexLocker mutexLocker(&m_mutex);
 
-	if(m_FCDThread) {
+	if (m_FCDThread)
+	{
 		m_FCDThread->stopWork();
 		// wait for thread to quit ?
 		delete m_FCDThread;
-		m_FCDThread = NULL;
+		m_FCDThread = 0;
 	}
+
 	m_deviceDescription.clear();
 }
 
@@ -121,45 +141,66 @@ const QString& FCDInput::getDeviceDescription() const
 
 int FCDInput::getSampleRate() const
 {
-	return 192000;
+	return 96000;
 }
 
 quint64 FCDInput::getCenterFrequency() const
 {
-	return m_generalSettings.m_centerFrequency;
+	return m_settings.centerFrequency;
 }
 
-bool FCDInput::handleMessage(Message* message)
+bool FCDInput::handleMessage(const Message& message)
 {
-	if(MsgConfigureFCD::match(message)) {
-		MsgConfigureFCD* conf = (MsgConfigureFCD*)message;
-		applySettings(conf->getGeneralSettings(), conf->getSettings(), false);
-		message->completed();
+	if(MsgConfigureFCD::match(message))
+	{
+		MsgConfigureFCD& conf = (MsgConfigureFCD&) message;
+		applySettings(conf.getSettings(), false);
 		return true;
-	} else {
+	}
+	else
+	{
 		return false;
 	}
 }
 
-void FCDInput::applySettings(const GeneralSettings& generalSettings, const Settings& settings, bool force)
+void FCDInput::applySettings(const Settings& settings, bool force)
 {
-	bool freqChange;
+	bool sampleSourcChange = false;
 
-	if((m_generalSettings.m_centerFrequency != generalSettings.m_centerFrequency))
-		freqChange = true;
-	else
-		freqChange = false;
-
-	if(freqChange || force) {
-		m_generalSettings.m_centerFrequency = generalSettings.m_centerFrequency;
-		set_center_freq( (double)(generalSettings.m_centerFrequency) );
+	if ((m_settings.centerFrequency != settings.centerFrequency))
+	{
+		m_settings.centerFrequency = settings.centerFrequency;
+		set_center_freq((double) m_settings.centerFrequency);
+		sampleSourcChange = true;
 	}
 
-	if(!freqChange || force) {
-		set_lna_gain(settings.gain);
-		set_bias_t(settings.bias);
+	if (!sampleSourcChange || force)
+	{
+		set_lna_gain(settings.gain > 0);
+		set_bias_t(settings.bias > 0);
 	}	
+}
 
+void FCDInput::set_center_freq(double freq)
+{
+	if (fcdAppSetFreq(freq) == FCD_MODE_NONE)
+	{
+		qDebug("No FCD HID found for frquency change");
+	}
+}
+
+void FCDInput::set_bias_t(bool on)
+{
+	quint8 cmd = on ? 1 : 0;
+
+	fcdAppSetParam(FCD_CMD_APP_SET_BIAS_TEE, &cmd, 1);
+}
+
+void FCDInput::set_lna_gain(bool on)
+{
+	quint8 cmd = on ? 1 : 0;
+
+	fcdAppSetParam(FCD_CMD_APP_SET_LNA_GAIN, &cmd, 1);
 }
 
 

plugins/samplesource/fcd/fcdinput.h

@@ -23,7 +23,7 @@
 
 struct fcd_buffer {
 	void *start;
-	size_t length;
+	std::size_t length;
 };
 
 class FCDThread;
@@ -32,6 +32,7 @@ class FCDInput : public SampleSource {
 public:
 	struct Settings {
 		Settings();
+		quint64 centerFrequency;
 		qint32 range;
 		qint32 gain;
 		qint32 bias;
@@ -44,46 +45,46 @@ public:
 		MESSAGE_CLASS_DECLARATION
 
 	public:
-		const GeneralSettings& getGeneralSettings() const { return m_generalSettings; }
 		const Settings& getSettings() const { return m_settings; }
 
-		static MsgConfigureFCD* create(const GeneralSettings& generalSettings, const Settings& settings)
+		static MsgConfigureFCD* create(const Settings& settings)
 		{
-			return new MsgConfigureFCD(generalSettings, settings);
+			return new MsgConfigureFCD(settings);
 		}
 
 	private:
-		GeneralSettings m_generalSettings;
 		Settings m_settings;
 
-		MsgConfigureFCD(const GeneralSettings& generalSettings, const Settings& settings) :
+		MsgConfigureFCD(const Settings& settings) :
 			Message(),
-			m_generalSettings(generalSettings),
 			m_settings(settings)
 		{ }
 	};
 
+	FCDInput();
+	virtual ~FCDInput();
 
-	FCDInput(MessageQueue* msgQueueToGUI);
-	~FCDInput();
+	virtual bool init(const Message& cmd);
+	virtual bool start(int device);
+	virtual void stop();
 
-	bool startInput(int device);
-	void stopInput();
+	virtual const QString& getDeviceDescription() const;
+	virtual int getSampleRate() const;
+	virtual quint64 getCenterFrequency() const;
+
+	virtual bool handleMessage(const Message& message);
 
-	const QString& getDeviceDescription() const;
-	int getSampleRate() const;
 	void set_center_freq(double freq);
 	void set_bias_t(bool on);
 	void set_lna_gain(bool on);
-	quint64 getCenterFrequency() const;
-	bool handleMessage(Message* message);
 
 private:
+	void applySettings(const Settings& settings, bool force);
+
 	QMutex m_mutex;
 	Settings m_settings;
 	FCDThread* m_FCDThread;
 	QString m_deviceDescription;
-	void applySettings(const GeneralSettings& generalSettings, const Settings& settings, bool force);
 };
 
 #endif // INCLUDE_FCD_H

plugins/samplesource/fcd/fcdsource.cpp

@@ -1,95 +0,0 @@
-/* (C)2015 John Greb
- *
- * Funcube Dongle command line interface
- * Copyright 2011 David Pello EA1IDZ
- * Copyright 2011 Pieter-Tjerk de Boer PA3FWM
- * Copyright 2012-2014 Alexandru Csete OZ9AEC
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public Licence version 3.
- */
-
-#include "fcdinput.h"
-#include "fcdthread.h"
-#include "qthid.h"
-
-bool FCDThread::OpenSource(const char* cardname)
-{
-	bool fail = false;
-	snd_pcm_hw_params_t* params;
-	//fcd_rate = FCDPP_RATE;
-	//fcd_channels =2;
-	//fcd_format = SND_PCM_SFMT_U16_LE;
-	snd_pcm_stream_t fcd_stream = SND_PCM_STREAM_CAPTURE;
-
-	if (fcd_handle)
-		return false;
-	if ( snd_pcm_open( &fcd_handle, cardname, fcd_stream, 0 ) < 0 )
-		return false;
-
-	snd_pcm_hw_params_alloca(&params);
-	if ( snd_pcm_hw_params_any(fcd_handle, params) < 0 )
-		fail = true;
-	else 	if ( snd_pcm_hw_params(fcd_handle, params) < 0 ) {
-			fail = true;
-			// TODO: check actual samplerate, may be crippled firmware
-		} else {
-			if ( snd_pcm_start(fcd_handle) < 0 )
-				fail = true;
-		}
-	if (fail) {
-		qCritical("Funcube Dongle stream start failed");
-		snd_pcm_close( fcd_handle );
-		return false;
-	} else {
-		qDebug("Funcube stream started");
-	}
-	return true;
-}
-
-void FCDThread::CloseSource()
-{
-	if (fcd_handle)
-		snd_pcm_close( fcd_handle );
-	fcd_handle = NULL;
-}
-
-void FCDInput::set_center_freq(double freq)
-{
-        if (fcdAppSetFreq(freq) == FCD_MODE_NONE)
-		qDebug("No FCD HID found for frquency change");
-}
-
-void FCDInput::set_bias_t(bool on)
-{
-	quint8 cmd = on ? 1 : 0;
-
-	fcdAppSetParam(FCD_CMD_APP_SET_BIAS_TEE, &cmd, 1);
-}
-
-void FCDInput::set_lna_gain(bool on)
-{
-	quint8 cmd = on ? 1 : 0;
-
-	fcdAppSetParam(FCD_CMD_APP_SET_LNA_GAIN, &cmd, 1);
-}
-
-int FCDThread::work(int n_items)
-{
-	int l;
-	SampleVector::iterator it;
-	void *out;
-
-	it = m_convertBuffer.begin();
-	out = (void *)&it[0];
-	l = snd_pcm_mmap_readi(fcd_handle, out, (snd_pcm_uframes_t)n_items);
-	if (l > 0)
-		m_sampleFifo->write(it, it + l);
-	if (l == -EPIPE) {
-		qDebug("FCD: Overrun detected");
-		return 0;
-	}
-	return l;
-}
-
-

plugins/samplesource/fcd/fcdthread.cpp

@@ -54,3 +54,84 @@ void FCDThread::run()
 	CloseSource();
 }
 
+bool FCDThread::OpenSource(const char* cardname)
+{
+	bool fail = false;
+	snd_pcm_hw_params_t* params;
+	//fcd_rate = FCDPP_RATE;
+	//fcd_channels =2;
+	//fcd_format = SND_PCM_SFMT_U16_LE;
+	snd_pcm_stream_t fcd_stream = SND_PCM_STREAM_CAPTURE;
+
+	if (fcd_handle)
+	{
+		return false;
+	}
+
+	if (snd_pcm_open(&fcd_handle, cardname, fcd_stream, 0) < 0)
+	{
+		return false;
+	}
+
+	snd_pcm_hw_params_alloca(&params);
+
+	if (snd_pcm_hw_params_any(fcd_handle, params) < 0)
+	{
+		fail = true;
+	}
+	else if (snd_pcm_hw_params(fcd_handle, params) < 0)
+	{
+		fail = true;
+		// TODO: check actual samplerate, may be crippled firmware
+	}
+	else
+	{
+		if (snd_pcm_start(fcd_handle) < 0)
+		{
+			fail = true;
+		}
+	}
+
+	if (fail)
+	{
+		qCritical("Funcube Dongle stream start failed");
+		snd_pcm_close( fcd_handle );
+		return false;
+	}
+	else
+	{
+		qDebug("Funcube stream started");
+	}
+
+	return true;
+}
+
+void FCDThread::CloseSource()
+{
+	if (fcd_handle)
+	{
+		snd_pcm_close( fcd_handle );
+	}
+
+	fcd_handle = NULL;
+}
+
+int FCDThread::work(int n_items)
+{
+	int l;
+	SampleVector::iterator it;
+	void *out;
+
+	it = m_convertBuffer.begin();
+	out = (void *)&it[0];
+	l = snd_pcm_mmap_readi(fcd_handle, out, (snd_pcm_uframes_t)n_items);
+	if (l > 0)
+		m_sampleFifo->write(it, it + l);
+	if (l == -EPIPE) {
+		qDebug("FCD: Overrun detected");
+		return 0;
+	}
+	return l;
+}
+
+

plugins/samplesource/filesource/filesourcegui.cpp

@@ -23,6 +23,7 @@
 #include "ui_filesourcegui.h"
 #include "plugin/pluginapi.h"
 #include "gui/colormapper.h"
+#include "dsp/dspengine.h"
 #include "mainwindow.h"
 
 #include "filesourcegui.h"
@@ -49,8 +50,8 @@ FileSourceGui::FileSourceGui(PluginAPI* pluginAPI, QWidget* parent) :
 	connect(&(m_pluginAPI->getMainWindow()->getMasterTimer()), SIGNAL(timeout()), this, SLOT(tick()));
 	displaySettings();
 
-	m_sampleSource = new FileSourceInput(m_pluginAPI->getMainWindowMessageQueue(), m_pluginAPI->getMainWindow()->getMasterTimer());
-	m_pluginAPI->setSampleSource(m_sampleSource);
+	m_sampleSource = new FileSourceInput(m_pluginAPI->getMainWindow()->getMasterTimer());
+	DSPEngine::instance()->setSource(m_sampleSource);
 }
 
 FileSourceGui::~FileSourceGui()
@@ -75,32 +76,14 @@ QString FileSourceGui::getName() const
 
 void FileSourceGui::resetToDefaults()
 {
-	m_generalSettings.resetToDefaults();
 	m_settings.resetToDefaults();
 	displaySettings();
 	sendSettings();
 }
 
-QByteArray FileSourceGui::serializeGeneral() const
-{
-	return m_generalSettings.serialize();
-}
-
-bool FileSourceGui::deserializeGeneral(const QByteArray&data)
-{
-	if(m_generalSettings.deserialize(data)) {
-		displaySettings();
-		sendSettings();
-		return true;
-	} else {
-		resetToDefaults();
-		return false;
-	}
-}
-
 qint64 FileSourceGui::getCenterFrequency() const
 {
-	return m_generalSettings.m_centerFrequency;
+	return m_centerFrequency;
 }
 
 QByteArray FileSourceGui::serialize() const
@@ -120,28 +103,25 @@ bool FileSourceGui::deserialize(const QByteArray& data)
 	}
 }
 
-bool FileSourceGui::handleMessage(Message* message)
+bool FileSourceGui::handleMessage(const Message& message)
 {
 	if(FileSourceInput::MsgReportFileSourceAcquisition::match(message))
 	{
-		m_acquisition = ((FileSourceInput::MsgReportFileSourceAcquisition*)message)->getAcquisition();
+		m_acquisition = ((FileSourceInput::MsgReportFileSourceAcquisition&)message).getAcquisition();
 		updateWithAcquisition();
-		message->completed();
 		return true;
 	}
 	else if(FileSourceInput::MsgReportFileSourceStreamData::match(message))
 	{
-		m_sampleRate = ((FileSourceInput::MsgReportFileSourceStreamData*)message)->getSampleRate();
-		m_centerFrequency = ((FileSourceInput::MsgReportFileSourceStreamData*)message)->getCenterFrequency();
-		m_startingTimeStamp = ((FileSourceInput::MsgReportFileSourceStreamData*)message)->getStartingTimeStamp();
-		message->completed();
+		m_sampleRate = ((FileSourceInput::MsgReportFileSourceStreamData&)message).getSampleRate();
+		m_centerFrequency = ((FileSourceInput::MsgReportFileSourceStreamData&)message).getCenterFrequency();
+		m_startingTimeStamp = ((FileSourceInput::MsgReportFileSourceStreamData&)message).getStartingTimeStamp();
 		updateWithStreamData();
 		return true;
 	}
 	else if(FileSourceInput::MsgReportFileSourceStreamTiming::match(message))
 	{
-		m_samplesCount = ((FileSourceInput::MsgReportFileSourceStreamTiming*)message)->getSamplesCount();
-		message->completed();
+		m_samplesCount = ((FileSourceInput::MsgReportFileSourceStreamTiming&)message).getSamplesCount();
 		updateWithStreamTime();
 		return true;
 	}
@@ -157,31 +137,25 @@ void FileSourceGui::displaySettings()
 
 void FileSourceGui::sendSettings()
 {
-	/*
-	if(!m_updateTimer.isActive())
-		m_updateTimer.start(100);
-		*/
 }
 
 void FileSourceGui::updateHardware()
 {
-	/*
-	FileSourceInput::MsgConfigureFileSource* message = FileSourceInput::MsgConfigureFileSource::create(m_generalSettings, m_settings);
-	message->submit(m_pluginAPI->getDSPEngineMessageQueue());
-	m_updateTimer.stop();*/
 }
 
 void FileSourceGui::on_play_toggled(bool checked)
 {
 	FileSourceInput::MsgConfigureFileSourceWork* message = FileSourceInput::MsgConfigureFileSourceWork::create(checked);
-	message->submit(m_pluginAPI->getDSPEngineMessageQueue());
+	m_sampleSource->getInputMessageQueue()->push(message);
 }
 
 void FileSourceGui::on_showFileDialog_clicked(bool checked)
 {
 	QString fileName = QFileDialog::getOpenFileName(this,
 	    tr("Open I/Q record file"), ".", tr("SDR I/Q Files (*.sdriq)"));
-	if (fileName != "") {
+
+	if (fileName != "")
+	{
 		m_fileName = fileName;
 		ui->fileNameText->setText(m_fileName);
 		configureFileName();
@@ -192,7 +166,7 @@ void FileSourceGui::configureFileName()
 {
 	qDebug() << "FileSourceGui::configureFileName: " << m_fileName.toStdString().c_str();
 	FileSourceInput::MsgConfigureFileSourceName* message = FileSourceInput::MsgConfigureFileSourceName::create(m_fileName);
-	message->submit(m_pluginAPI->getDSPEngineMessageQueue());
+	m_sampleSource->getInputMessageQueue()->push(message);
 }
 
 void FileSourceGui::updateWithAcquisition()
@@ -239,6 +213,6 @@ void FileSourceGui::tick()
 {
 	if ((++m_tickCount & 0xf) == 0) {
 		FileSourceInput::MsgConfigureFileSourceStreamTiming* message = FileSourceInput::MsgConfigureFileSourceStreamTiming::create();
-		message->submit(m_pluginAPI->getDSPEngineMessageQueue());
+		m_sampleSource->getInputMessageQueue()->push(message);
 	}
 }

plugins/samplesource/filesource/filesourcegui.h

@@ -33,25 +33,22 @@ class FileSourceGui : public QWidget, public PluginGUI {
 
 public:
 	explicit FileSourceGui(PluginAPI* pluginAPI, QWidget* parent = NULL);
-	~FileSourceGui();
+	virtual ~FileSourceGui();
 	void destroy();
 
 	void setName(const QString& name);
 	QString getName() const;
 
 	void resetToDefaults();
-	QByteArray serializeGeneral() const;
-	bool deserializeGeneral(const QByteArray&data);
 	qint64 getCenterFrequency() const;
 	QByteArray serialize() const;
 	bool deserialize(const QByteArray& data);
-	bool handleMessage(Message* message);
+	virtual bool handleMessage(const Message& message);
 
 private:
 	Ui::FileSourceGui* ui;
 
 	PluginAPI* m_pluginAPI;
-	SampleSource::GeneralSettings m_generalSettings;
 	FileSourceInput::Settings m_settings;
 	QTimer m_updateTimer;
 	std::vector<int> m_gains;

plugins/samplesource/filesource/filesourceinput.cpp

@@ -69,8 +69,7 @@ bool FileSourceInput::Settings::deserialize(const QByteArray& data)
 	}
 }
 
-FileSourceInput::FileSourceInput(MessageQueue* msgQueueToGUI, const QTimer& masterTimer) :
-	SampleSource(msgQueueToGUI),
+FileSourceInput::FileSourceInput(const QTimer& masterTimer) :
 	m_settings(),
 	m_fileSourceThread(NULL),
 	m_deviceDescription(),
@@ -84,7 +83,7 @@ FileSourceInput::FileSourceInput(MessageQueue* msgQueueToGUI, const QTimer& mast
 
 FileSourceInput::~FileSourceInput()
 {
-	stopInput();
+	stop();
 }
 
 void FileSourceInput::openFileStream()
@@ -105,19 +104,15 @@ void FileSourceInput::openFileStream()
 	m_centerFrequency = header.centerFrequency;
 	m_startingTimeStamp = header.startTimeStamp;
 
-	MsgReportFileSourceStreamData::create(m_sampleRate, m_centerFrequency, m_startingTimeStamp)->submit(m_guiMessageQueue); // file stream data
+	MsgReportFileSourceStreamData *report = MsgReportFileSourceStreamData::create(m_sampleRate, m_centerFrequency, m_startingTimeStamp); // file stream data
+	getOutputMessageQueue()->push(report);
 }
 
-bool FileSourceInput::startInput(int device)
+bool FileSourceInput::start(int device)
 {
 	QMutexLocker mutexLocker(&m_mutex);
 	qDebug() << "FileSourceInput::startInput";
 
-	/*
-	if (!m_ifstream.is_open()) {
-		openFileStream();
-	}*/
-
 	if (m_ifstream.tellg() != 0) {
 		m_ifstream.clear();
 		m_ifstream.seekg(0, std::ios::beg);
@@ -132,7 +127,8 @@ bool FileSourceInput::startInput(int device)
 
 	if((m_fileSourceThread = new FileSourceThread(&m_ifstream, &m_sampleFifo)) == NULL) {
 		qFatal("out of memory");
-		goto failed;
+		stop();
+		return false;
 	}
 
 	m_fileSourceThread->setSamplerate(m_sampleRate);
@@ -144,29 +140,28 @@ bool FileSourceInput::startInput(int device)
 	//applySettings(m_generalSettings, m_settings, true);
 	qDebug("FileSourceInput::startInput: started");
 
-	MsgReportFileSourceAcquisition::create(true)->submit(m_guiMessageQueue); // acquisition on
+	MsgReportFileSourceAcquisition *report = MsgReportFileSourceAcquisition::create(true); // acquisition on
+	getOutputMessageQueue()->push(report);
 
 	return true;
-
-failed:
-	stopInput();
-	return false;
 }
 
-void FileSourceInput::stopInput()
+void FileSourceInput::stop()
 {
-	qDebug() << "FileSourceInput::stopInput";
+	qDebug() << "FileSourceInput::stop";
 	QMutexLocker mutexLocker(&m_mutex);
 
-	if(m_fileSourceThread != NULL) {
+	if(m_fileSourceThread != 0)
+	{
 		m_fileSourceThread->stopWork();
 		delete m_fileSourceThread;
-		m_fileSourceThread = NULL;
+		m_fileSourceThread = 0;
 	}
 
 	m_deviceDescription.clear();
 
-	MsgReportFileSourceAcquisition::create(false)->submit(m_guiMessageQueue); // acquisition off
+	MsgReportFileSourceAcquisition *report = MsgReportFileSourceAcquisition::create(false); // acquisition off
+	getOutputMessageQueue()->push(report);
 }
 
 const QString& FileSourceInput::getDeviceDescription() const
@@ -189,40 +184,52 @@ std::time_t FileSourceInput::getStartingTimeStamp() const
 	return m_startingTimeStamp;
 }
 
-bool FileSourceInput::handleMessage(Message* message)
+bool FileSourceInput::handleMessage(const Message& message)
 {
 	if (MsgConfigureFileSourceName::match(message))
 	{
-		MsgConfigureFileSourceName* conf = (MsgConfigureFileSourceName*) message;
-		m_fileName = conf->getFileName();
+		MsgConfigureFileSourceName& conf = (MsgConfigureFileSourceName&) message;
+		m_fileName = conf.getFileName();
 		openFileStream();
-		message->completed();
 		return true;
 	}
 	else if (MsgConfigureFileSourceWork::match(message))
 	{
-		MsgConfigureFileSourceWork* conf = (MsgConfigureFileSourceWork*) message;
-		bool working = conf->isWorking();
+		MsgConfigureFileSourceWork& conf = (MsgConfigureFileSourceWork&) message;
+		bool working = conf.isWorking();
+
 		if (m_fileSourceThread != 0)
 		{
-			if (working) {
+			if (working)
+			{
 				m_fileSourceThread->startWork();
-			} else {
+			}
+			else
+			{
 				m_fileSourceThread->stopWork();
 			}
 
-			MsgReportFileSourceStreamTiming::create(m_fileSourceThread->getSamplesCount())->submit(m_guiMessageQueue);
+			MsgReportFileSourceStreamTiming *report =
+					MsgReportFileSourceStreamTiming::create(m_fileSourceThread->getSamplesCount());
+			getOutputMessageQueue()->push(report);
 		}
-		message->completed();
+
 		return true;
 	}
 	else if (MsgConfigureFileSourceStreamTiming::match(message))
 	{
-		if (m_fileSourceThread != 0) {
-			MsgReportFileSourceStreamTiming::create(m_fileSourceThread->getSamplesCount())->submit(m_guiMessageQueue);
-		}else {
-			MsgReportFileSourceStreamTiming::create(0)->submit(m_guiMessageQueue);
+		MsgReportFileSourceStreamTiming *report;
+
+		if (m_fileSourceThread != 0)
+		{
+			report = MsgReportFileSourceStreamTiming::create(m_fileSourceThread->getSamplesCount());
 		}
+		else
+		{
+			report = MsgReportFileSourceStreamTiming::create(0);
+		}
+
+		getOutputMessageQueue()->push(report);
 	}
 	else
 	{
@@ -230,30 +237,38 @@ bool FileSourceInput::handleMessage(Message* message)
 	}
 }
 
-bool FileSourceInput::applySettings(const GeneralSettings& generalSettings, const Settings& settings, bool force)
+bool FileSourceInput::applySettings(const Settings& settings, bool force)
 {
 	QMutexLocker mutexLocker(&m_mutex);
 	bool wasRunning = false;
 
-	if((m_settings.m_fileName != settings.m_fileName) || force) {
+	if((m_settings.m_fileName != settings.m_fileName) || force)
+	{
 		m_settings.m_fileName = settings.m_fileName;
 
-		if (m_fileSourceThread != 0) {
+		if (m_fileSourceThread != 0)
+		{
 			wasRunning = m_fileSourceThread->isRunning();
-			if (wasRunning) {
+
+			if (wasRunning)
+			{
 				m_fileSourceThread->stopWork();
 			}
 		}
 
-		if (m_ifstream.is_open()) {
+		if (m_ifstream.is_open())
+		{
 			m_ifstream.close();
 		}
 
 		openFileStream();
 
-		if (m_fileSourceThread != 0) {
+		if (m_fileSourceThread != 0)
+		{
 			m_fileSourceThread->setSamplerate(m_sampleRate);
-			if (wasRunning) {
+
+			if (wasRunning)
+			{
 				m_fileSourceThread->startWork();
 			}
 		}

plugins/samplesource/filesource/filesourceinput.h

@@ -41,21 +41,18 @@ public:
 		MESSAGE_CLASS_DECLARATION
 
 	public:
-		const GeneralSettings& getGeneralSettings() const { return m_generalSettings; }
 		const Settings& getSettings() const { return m_settings; }
 
-		static MsgConfigureFileSource* create(const GeneralSettings& generalSettings, const Settings& settings)
+		static MsgConfigureFileSource* create(const Settings& settings)
 		{
-			return new MsgConfigureFileSource(generalSettings, settings);
+			return new MsgConfigureFileSource(settings);
 		}
 
 	private:
-		GeneralSettings m_generalSettings;
 		Settings m_settings;
 
-		MsgConfigureFileSource(const GeneralSettings& generalSettings, const Settings& settings) :
+		MsgConfigureFileSource(const Settings& settings) :
 			Message(),
-			m_generalSettings(generalSettings),
 			m_settings(settings)
 		{ }
 	};
@@ -183,18 +180,19 @@ public:
 		{ }
 	};
 
-	FileSourceInput(MessageQueue* msgQueueToGUI, const QTimer& masterTimer);
-	~FileSourceInput();
+	FileSourceInput(const QTimer& masterTimer);
+	virtual ~FileSourceInput();
 
-	bool startInput(int device);
-	void stopInput();
+	virtual bool init(const Message& message);
+	virtual bool start(int device);
+	virtual void stop();
 
-	const QString& getDeviceDescription() const;
-	int getSampleRate() const;
-	quint64 getCenterFrequency() const;
+	virtual const QString& getDeviceDescription() const;
+	virtual int getSampleRate() const;
+	virtual quint64 getCenterFrequency() const;
 	std::time_t getStartingTimeStamp() const;
 
-	bool handleMessage(Message* message);
+	virtual bool handleMessage(const Message& message);
 
 private:
 	QMutex m_mutex;
@@ -208,7 +206,7 @@ private:
 	std::time_t m_startingTimeStamp;
 	const QTimer& m_masterTimer;
 
-	bool applySettings(const GeneralSettings& generalSettings, const Settings& settings, bool force);
+	bool applySettings(const Settings& settings, bool force);
 	void openFileStream();
 };
 

plugins/samplesource/rtlsdr/rtlsdrgui.cpp

@@ -2,13 +2,14 @@
 #include "ui_rtlsdrgui.h"
 #include "plugin/pluginapi.h"
 #include "gui/colormapper.h"
+#include "dsp/dspengine.h"
 
 RTLSDRGui::RTLSDRGui(PluginAPI* pluginAPI, QWidget* parent) :
 	QWidget(parent),
 	ui(new Ui::RTLSDRGui),
 	m_pluginAPI(pluginAPI),
 	m_settings(),
-	m_sampleSource(NULL)
+	m_sampleSource(0)
 {
 	ui->setupUi(this);
 	ui->centerFrequency->setColorMapper(ColorMapper(ColorMapper::ReverseGold));
@@ -16,8 +17,8 @@ RTLSDRGui::RTLSDRGui(PluginAPI* pluginAPI, QWidget* parent) :
 	connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateHardware()));
 	displaySettings();
 
-	m_sampleSource = new RTLSDRInput(m_pluginAPI->getMainWindowMessageQueue());
-	m_pluginAPI->setSampleSource(m_sampleSource);
+	m_sampleSource = new RTLSDRInput();
+	DSPEngine::instance()->setSource(m_sampleSource);
 }
 
 RTLSDRGui::~RTLSDRGui()
@@ -42,32 +43,14 @@ QString RTLSDRGui::getName() const
 
 void RTLSDRGui::resetToDefaults()
 {
-	m_generalSettings.resetToDefaults();
 	m_settings.resetToDefaults();
 	displaySettings();
 	sendSettings();
 }
 
-QByteArray RTLSDRGui::serializeGeneral() const
-{
-	return m_generalSettings.serialize();
-}
-
-bool RTLSDRGui::deserializeGeneral(const QByteArray&data)
-{
-	if(m_generalSettings.deserialize(data)) {
-		displaySettings();
-		sendSettings();
-		return true;
-	} else {
-		resetToDefaults();
-		return false;
-	}
-}
-
 qint64 RTLSDRGui::getCenterFrequency() const
 {
-	return m_generalSettings.m_centerFrequency;
+	return m_settings.m_centerFrequency;
 }
 
 QByteArray RTLSDRGui::serialize() const
@@ -77,53 +60,65 @@ QByteArray RTLSDRGui::serialize() const
 
 bool RTLSDRGui::deserialize(const QByteArray& data)
 {
-	if(m_settings.deserialize(data)) {
+	if (m_settings.deserialize(data))
+	{
 		displaySettings();
 		sendSettings();
 		return true;
-	} else {
+	}
+	else
+	{
 		resetToDefaults();
 		return false;
 	}
 }
 
-bool RTLSDRGui::handleMessage(Message* message)
+bool RTLSDRGui::handleMessage(const Message& message)
 {
-	if(RTLSDRInput::MsgReportRTLSDR::match(message)) {
-		m_gains = ((RTLSDRInput::MsgReportRTLSDR*)message)->getGains();
+	if (RTLSDRInput::MsgReportRTLSDR::match(message))
+	{
+		m_gains = ((RTLSDRInput::MsgReportRTLSDR&) message).getGains();
 		displaySettings();
-		message->completed();
 		return true;
-	} else {
+	}
+	else
+	{
 		return false;
 	}
 }
 
 void RTLSDRGui::displaySettings()
 {
-	ui->centerFrequency->setValue(m_generalSettings.m_centerFrequency / 1000);
-	ui->samplerateText->setText(tr("%1k").arg(m_settings.m_samplerate / 1000));
-	unsigned int sampleRateIndex = RTLSDRSampleRates::getRateIndex(m_settings.m_samplerate);
+	ui->centerFrequency->setValue(m_settings.m_centerFrequency / 1000);
+	ui->samplerateText->setText(tr("%1k").arg(m_settings.m_devSampleRate / 1000));
+	unsigned int sampleRateIndex = RTLSDRSampleRates::getRateIndex(m_settings.m_devSampleRate);
 	ui->samplerate->setValue(sampleRateIndex);
 	ui->ppm->setValue(m_settings.m_loPpmCorrection);
 	ui->ppmText->setText(tr("%1").arg(m_settings.m_loPpmCorrection));
 	ui->decimText->setText(tr("%1").arg(1<<m_settings.m_log2Decim));
 	ui->decim->setValue(m_settings.m_log2Decim);
 
-	if(m_gains.size() > 0) {
+	if (m_gains.size() > 0)
+	{
 		int dist = abs(m_settings.m_gain - m_gains[0]);
 		int pos = 0;
-		for(uint i = 1; i < m_gains.size(); i++) {
-			if(abs(m_settings.m_gain - m_gains[i]) < dist) {
+
+		for (uint i = 1; i < m_gains.size(); i++)
+		{
+			if (abs(m_settings.m_gain - m_gains[i]) < dist)
+			{
 				dist = abs(m_settings.m_gain - m_gains[i]);
 				pos = i;
 			}
 		}
+
 		ui->gainText->setText(tr("%1.%2").arg(m_gains[pos] / 10).arg(abs(m_gains[pos] % 10)));
 		ui->gain->setMaximum(m_gains.size() - 1);
 		ui->gain->setEnabled(true);
 		ui->gain->setValue(pos);
-	} else {
+	}
+	else
+	{
 		ui->gain->setMaximum(0);
 		ui->gain->setEnabled(false);
 		ui->gain->setValue(0);
@@ -133,40 +128,54 @@ void RTLSDRGui::displaySettings()
 void RTLSDRGui::sendSettings()
 {
 	if(!m_updateTimer.isActive())
+	{
 		m_updateTimer.start(100);
+	}
 }
 
 void RTLSDRGui::on_centerFrequency_changed(quint64 value)
 {
-	m_generalSettings.m_centerFrequency = value * 1000;
+	m_settings.m_centerFrequency = value * 1000;
 	sendSettings();
 }
 
 void RTLSDRGui::on_decim_valueChanged(int value)
 {
 	if ((value <0) || (value > 4))
+	{
 		return;
+	}
+
 	ui->decimText->setText(tr("%1").arg(1<<value));
 	m_settings.m_log2Decim = value;
+
 	sendSettings();
 }
 
 void RTLSDRGui::on_ppm_valueChanged(int value)
 {
-	if((value > 99) || (value < -99))
+	if ((value > 99) || (value < -99))
+	{
 		return;
+	}
+
 	ui->ppmText->setText(tr("%1").arg(value));
 	m_settings.m_loPpmCorrection = value;
+
 	sendSettings();
 }
 
 void RTLSDRGui::on_gain_valueChanged(int value)
 {
-	if(value > (int)m_gains.size())
+	if (value > (int)m_gains.size())
+	{
 		return;
+	}
+
 	int gain = m_gains[value];
 	ui->gainText->setText(tr("%1.%2").arg(gain / 10).arg(abs(gain % 10)));
 	m_settings.m_gain = gain;
+
 	sendSettings();
 }
 
@@ -174,34 +183,39 @@ void RTLSDRGui::on_samplerate_valueChanged(int value)
 {
 	int newrate = RTLSDRSampleRates::getRate(value);
 	ui->samplerateText->setText(tr("%1k").arg(newrate));
-	m_settings.m_samplerate = newrate * 1000;
+	m_settings.m_devSampleRate = newrate * 1000;
+
 	sendSettings();
 }
 
 void RTLSDRGui::updateHardware()
 {
-	RTLSDRInput::MsgConfigureRTLSDR* message = RTLSDRInput::MsgConfigureRTLSDR::create(m_generalSettings, m_settings);
-	message->submit(m_pluginAPI->getDSPEngineMessageQueue());
+	RTLSDRInput::MsgConfigureRTLSDR* message = RTLSDRInput::MsgConfigureRTLSDR::create(m_settings);
+	m_sampleSource->getInputMessageQueue()->push(message);
 	m_updateTimer.stop();
 }
 
-void RTLSDRGui::on_checkBox_stateChanged(int state) {
-	if (state == Qt::Checked){
+void RTLSDRGui::on_checkBox_stateChanged(int state)
+{
+	if (state == Qt::Checked)
+	{
 		// Direct Modes: 0: off, 1: I, 2: Q, 3: NoMod.
 		((RTLSDRInput*)m_sampleSource)->set_ds_mode(3);
 		ui->gain->setEnabled(false);
 		ui->centerFrequency->setValueRange(7, 1000U, 275000U);
 		ui->centerFrequency->setValue(7000);
-		m_generalSettings.m_centerFrequency = 7000 * 1000;
+		m_settings.m_centerFrequency = 7000 * 1000;
 	}
-	else {
+	else
+	{
 		((RTLSDRInput*)m_sampleSource)->set_ds_mode(0);
 		ui->gain->setEnabled(true);
 		ui->centerFrequency->setValueRange(7, 28500U, 1700000U);
 		ui->centerFrequency->setValue(434000);
 		ui->gain->setValue(0);
-		m_generalSettings.m_centerFrequency = 434000 * 1000;
+		m_settings.m_centerFrequency = 435000 * 1000;
 	}
+
 	sendSettings();
 }
 

plugins/samplesource/rtlsdr/rtlsdrgui.h

@@ -17,25 +17,22 @@ class RTLSDRGui : public QWidget, public PluginGUI {
 
 public:
 	explicit RTLSDRGui(PluginAPI* pluginAPI, QWidget* parent = NULL);
-	~RTLSDRGui();
+	virtual ~RTLSDRGui();
 	void destroy();
 
 	void setName(const QString& name);
 	QString getName() const;
 
 	void resetToDefaults();
-	QByteArray serializeGeneral() const;
-	bool deserializeGeneral(const QByteArray&data);
 	qint64 getCenterFrequency() const;
 	QByteArray serialize() const;
 	bool deserialize(const QByteArray& data);
-	bool handleMessage(Message* message);
+	virtual bool handleMessage(const Message& message);
 
 private:
 	Ui::RTLSDRGui* ui;
 
 	PluginAPI* m_pluginAPI;
-	SampleSource::GeneralSettings m_generalSettings;
 	RTLSDRInput::Settings m_settings;
 	QTimer m_updateTimer;
 	std::vector<int> m_gains;

plugins/samplesource/rtlsdr/rtlsdrinput.cpp

@@ -26,8 +26,9 @@ MESSAGE_CLASS_DEFINITION(RTLSDRInput::MsgConfigureRTLSDR, Message)
 MESSAGE_CLASS_DEFINITION(RTLSDRInput::MsgReportRTLSDR, Message)
 
 RTLSDRInput::Settings::Settings() :
+	m_devSampleRate(1024*1000),
+	m_centerFrequency(435000*1000),
 	m_gain(0),
-	m_samplerate(1024000),
 	m_loPpmCorrection(0),
 	m_log2Decim(4)
 {
@@ -35,8 +36,9 @@ RTLSDRInput::Settings::Settings() :
 
 void RTLSDRInput::Settings::resetToDefaults()
 {
+	m_devSampleRate = 1024*1000;
+	m_centerFrequency = 435000*1000;
 	m_gain = 0;
-	m_samplerate = 1024000;
 	m_loPpmCorrection = 0;
 	m_log2Decim = 4;
 }
@@ -44,10 +46,11 @@ void RTLSDRInput::Settings::resetToDefaults()
 QByteArray RTLSDRInput::Settings::serialize() const
 {
 	SimpleSerializer s(1);
-	s.writeS32(1, m_gain);
-	s.writeS32(2, m_samplerate);
-	s.writeS32(3, m_loPpmCorrection);
-	s.writeU32(4, m_log2Decim);
+	s.writeS32(1, m_devSampleRate);
+	s.writeU64(2, m_centerFrequency);
+	s.writeS32(3, m_gain);
+	s.writeS32(4, m_loPpmCorrection);
+	s.writeU32(5, m_log2Decim);
 	return s.final();
 }
 
@@ -55,43 +58,49 @@ bool RTLSDRInput::Settings::deserialize(const QByteArray& data)
 {
 	SimpleDeserializer d(data);
 
-	if(!d.isValid()) {
+	if (!d.isValid())
+	{
 		resetToDefaults();
 		return false;
 	}
 
-	if(d.getVersion() == 1) {
-		d.readS32(1, &m_gain, 0);
-		d.readS32(2, &m_samplerate, 0);
-		d.readS32(3, &m_loPpmCorrection, 0);
-		d.readU32(4, &m_log2Decim, 4);
+	if(d.getVersion() == 1)
+	{
+		d.readS32(1, &m_devSampleRate, 1024*1000);
+		d.readU64(2, &m_centerFrequency, 435000*1000);
+		d.readS32(3, &m_gain, 0);
+		d.readS32(4, &m_loPpmCorrection, 0);
+		d.readU32(5, &m_log2Decim, 4);
 		return true;
-	} else {
+	}
+	else
+	{
 		resetToDefaults();
 		return false;
 	}
 }
 
-RTLSDRInput::RTLSDRInput(MessageQueue* msgQueueToGUI) :
-	SampleSource(msgQueueToGUI),
+RTLSDRInput::RTLSDRInput() :
 	m_settings(),
-	m_dev(NULL),
-	m_rtlSDRThread(NULL),
+	m_dev(0),
+	m_rtlSDRThread(0),
 	m_deviceDescription()
 {
 }
 
 RTLSDRInput::~RTLSDRInput()
 {
-	stopInput();
+	stop();
 }
 
-bool RTLSDRInput::startInput(int device)
+bool RTLSDRInput::start(int device)
 {
 	QMutexLocker mutexLocker(&m_mutex);
 
-	if(m_dev != NULL)
-		stopInput();
+	if (m_dev != 0)
+	{
+		stop();
+	}
 
 	char vendor[256];
 	char product[256];
@@ -99,12 +108,14 @@ bool RTLSDRInput::startInput(int device)
 	int res;
 	int numberOfGains;
 
-	if(!m_sampleFifo.setSize(96000 * 4)) {
+	if (!m_sampleFifo.setSize(96000 * 4))
+	{
 		qCritical("Could not allocate SampleFifo");
 		return false;
 	}
 
-	if((res = rtlsdr_open(&m_dev, device)) < 0) {
+	if ((res = rtlsdr_open(&m_dev, device)) < 0)
+	{
 		qCritical("could not open RTLSDR #%d: %s", device, strerror(errno));
 		return false;
 	}
@@ -112,74 +123,101 @@ bool RTLSDRInput::startInput(int device)
 	vendor[0] = '\0';
 	product[0] = '\0';
 	serial[0] = '\0';
-	if((res = rtlsdr_get_usb_strings(m_dev, vendor, product, serial)) < 0) {
+
+	if ((res = rtlsdr_get_usb_strings(m_dev, vendor, product, serial)) < 0)
+	{
 		qCritical("error accessing USB device");
-		goto failed;
+		stop();
+		return false;
 	}
+
 	qWarning("RTLSDRInput open: %s %s, SN: %s", vendor, product, serial);
 	m_deviceDescription = QString("%1 (SN %2)").arg(product).arg(serial);
 
-	if((res = rtlsdr_set_sample_rate(m_dev, 1024000)) < 0) {
+	if ((res = rtlsdr_set_sample_rate(m_dev, 1024000)) < 0)
+	{
 		qCritical("could not set sample rate: 1024k S/s");
-		goto failed;
+		stop();
+		return false;
 	}
 
-	if((res = rtlsdr_set_tuner_gain_mode(m_dev, 1)) < 0) {
+	if ((res = rtlsdr_set_tuner_gain_mode(m_dev, 1)) < 0)
+	{
 		qCritical("error setting tuner gain mode");
-		goto failed;
+		stop();
+		return false;
 	}
-	if((res = rtlsdr_set_agc_mode(m_dev, 0)) < 0) {
+
+	if ((res = rtlsdr_set_agc_mode(m_dev, 0)) < 0)
+	{
 		qCritical("error setting agc mode");
-		goto failed;
+		stop();
+		return false;
 	}
 
 	numberOfGains = rtlsdr_get_tuner_gains(m_dev, NULL);
-	if(numberOfGains < 0) {
+
+	if (numberOfGains < 0)
+	{
 		qCritical("error getting number of gain values supported");
-		goto failed;
-	}
-	m_gains.resize(numberOfGains);
-	if(rtlsdr_get_tuner_gains(m_dev, &m_gains[0]) < 0) {
-		qCritical("error getting gain values");
-		goto failed;
-	}
-	if((res = rtlsdr_reset_buffer(m_dev)) < 0) {
-		qCritical("could not reset USB EP buffers: %s", strerror(errno));
-		goto failed;
+		stop();
+		return false;
 	}
 
-	if((m_rtlSDRThread = new RTLSDRThread(m_dev, &m_sampleFifo)) == NULL) {
-		qFatal("out of memory");
-		goto failed;
+	m_gains.resize(numberOfGains);
+
+	if (rtlsdr_get_tuner_gains(m_dev, &m_gains[0]) < 0)
+	{
+		qCritical("error getting gain values");
+		stop();
+		return false;
 	}
+
+	if ((res = rtlsdr_reset_buffer(m_dev)) < 0)
+	{
+		qCritical("could not reset USB EP buffers: %s", strerror(errno));
+		stop();
+		return false;
+	}
+
+	if ((m_rtlSDRThread = new RTLSDRThread(m_dev, &m_sampleFifo)) == NULL)
+	{
+		qFatal("out of memory");
+		stop();
+		return false;
+	}
+
 	m_rtlSDRThread->startWork();
 
 	mutexLocker.unlock();
-	applySettings(m_generalSettings, m_settings, true);
 
-	qDebug("RTLSDRInput: start");
-	MsgReportRTLSDR::create(m_gains)->submit(m_guiMessageQueue);
+	applySettings(m_settings, true);
+
+	qDebug("RTLSDRInput::start");
+
+	MsgReportRTLSDR *message = MsgReportRTLSDR::create(m_gains);
+	getOutputMessageQueue()->push(message);
 
 	return true;
-
-failed:
-	stopInput();
-	return false;
 }
 
-void RTLSDRInput::stopInput()
+void RTLSDRInput::stop()
 {
 	QMutexLocker mutexLocker(&m_mutex);
 
-	if(m_rtlSDRThread != NULL) {
+	if (m_rtlSDRThread != 0)
+	{
 		m_rtlSDRThread->stopWork();
 		delete m_rtlSDRThread;
-		m_rtlSDRThread = NULL;
+		m_rtlSDRThread = 0;
 	}
-	if(m_dev != NULL) {
+
+	if (m_dev != 0)
+	{
 		rtlsdr_close(m_dev);
-		m_dev = NULL;
+		m_dev = 0;
 	}
+
 	m_deviceDescription.clear();
 }
 
@@ -190,88 +228,110 @@ const QString& RTLSDRInput::getDeviceDescription() const
 
 int RTLSDRInput::getSampleRate() const
 {
-	int rate = m_settings.m_samplerate;
+	int rate = m_settings.m_devSampleRate;
 	return (rate / (1<<m_settings.m_log2Decim));
-	/*
-	if (rate < 800000)
-		return (rate / 4);
-	if ((rate == 1152000) || (rate == 2048000))
-		return (rate / 8);
-	return (rate / 16);
-	*/
 }
 
 quint64 RTLSDRInput::getCenterFrequency() const
 {
-	return m_generalSettings.m_centerFrequency;
+	return m_settings.m_centerFrequency;
 }
 
-bool RTLSDRInput::handleMessage(Message* message)
+bool RTLSDRInput::handleMessage(const Message& message)
 {
-	if(MsgConfigureRTLSDR::match(message)) {
-		MsgConfigureRTLSDR* conf = (MsgConfigureRTLSDR*)message;
-		if(!applySettings(conf->getGeneralSettings(), conf->getSettings(), false))
+	if (MsgConfigureRTLSDR::match(message))
+	{
+		MsgConfigureRTLSDR& conf = (MsgConfigureRTLSDR&) message;
+
+		if (!applySettings(conf.getSettings(), false))
+		{
 			qDebug("RTLSDR config error");
-		message->completed();
+		}
+
 		return true;
-	} else {
+	}
+	else
+	{
 		return false;
 	}
 }
 
-bool RTLSDRInput::applySettings(const GeneralSettings& generalSettings, const Settings& settings, bool force)
+bool RTLSDRInput::applySettings(const Settings& settings, bool force)
 {
 	QMutexLocker mutexLocker(&m_mutex);
 
-	if((m_settings.m_gain != settings.m_gain) || force) {
+	if ((m_settings.m_gain != settings.m_gain) || force)
+	{
 		m_settings.m_gain = settings.m_gain;
-		if(m_dev != NULL) {
+
+		if(m_dev != 0)
+		{
 			if(rtlsdr_set_tuner_gain(m_dev, m_settings.m_gain) != 0)
+			{
 				qDebug("rtlsdr_set_tuner_gain() failed");
-		}
-	}
-
-	if((m_settings.m_samplerate != settings.m_samplerate) || force) {
-		if(m_dev != NULL) {
-			if( rtlsdr_set_sample_rate(m_dev, settings.m_samplerate) < 0)
-				qCritical("could not set sample rate: %d", settings.m_samplerate);
-			else {
-				m_settings.m_samplerate = settings.m_samplerate;
-				m_rtlSDRThread->setSamplerate(settings.m_samplerate);
 			}
 		}
 	}
 
-	if((m_settings.m_loPpmCorrection != settings.m_loPpmCorrection) || force) {
-		if(m_dev != NULL) {
-			if( rtlsdr_set_freq_correction(m_dev, settings.m_loPpmCorrection) < 0)
+	if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || force)
+	{
+		if(m_dev != 0)
+		{
+			if( rtlsdr_set_sample_rate(m_dev, settings.m_devSampleRate) < 0)
+			{
+				qCritical("could not set sample rate: %d", settings.m_devSampleRate);
+			}
+			else
+			{
+				m_settings.m_devSampleRate = settings.m_devSampleRate;
+				m_rtlSDRThread->setSamplerate(settings.m_devSampleRate);
+			}
+		}
+	}
+
+	if ((m_settings.m_loPpmCorrection != settings.m_loPpmCorrection) || force)
+	{
+		if (m_dev != 0)
+		{
+			if (rtlsdr_set_freq_correction(m_dev, settings.m_loPpmCorrection) < 0)
+			{
 				qCritical("could not set LO ppm correction: %d", settings.m_loPpmCorrection);
-			else {
+			}
+			else
+			{
 				m_settings.m_loPpmCorrection = settings.m_loPpmCorrection;
-				//m_rtlSDRThread->setSamplerate(settings.m_samplerate);
 			}
 		}
 	}
 
-	if((m_settings.m_log2Decim != settings.m_log2Decim) || force) {
-		if(m_dev != NULL) {
+	if ((m_settings.m_log2Decim != settings.m_log2Decim) || force)
+	{
+		if(m_dev != 0)
+		{
 			m_settings.m_log2Decim = settings.m_log2Decim;
 			m_rtlSDRThread->setLog2Decimation(settings.m_log2Decim);
 		}
 	}
 
-	m_generalSettings.m_centerFrequency = generalSettings.m_centerFrequency;
-	if(m_dev != NULL) {
-		qint64 centerFrequency = m_generalSettings.m_centerFrequency + (m_settings.m_samplerate / 4);
+	m_settings.m_centerFrequency = settings.m_centerFrequency;
 
-		if (m_settings.m_log2Decim == 0) { // Little wooby-doop if no decimation
-			centerFrequency = m_generalSettings.m_centerFrequency;
-		} else {
-			centerFrequency = m_generalSettings.m_centerFrequency + (m_settings.m_samplerate / 4);
+	if(m_dev != 0)
+	{
+		qint64 centerFrequency = m_settings.m_centerFrequency + (m_settings.m_devSampleRate / 4);
+
+		if (m_settings.m_log2Decim == 0)
+		{ // Little wooby-doop if no decimation
+			centerFrequency = m_settings.m_centerFrequency;
+		}
+		else
+		{
+			centerFrequency = m_settings.m_centerFrequency + (m_settings.m_devSampleRate / 4);
 		}
 
-		if(rtlsdr_set_center_freq( m_dev, centerFrequency ) != 0)
-			qDebug("osmosdr_set_center_freq(%lld) failed", m_generalSettings.m_centerFrequency);
+		if (rtlsdr_set_center_freq( m_dev, centerFrequency ) != 0)
+		{
+			qDebug("rtlsdr_set_center_freq(%lld) failed", m_settings.m_centerFrequency);
+		}
 	}
 
 	return true;

plugins/samplesource/rtlsdr/rtlsdrinput.h

@@ -27,8 +27,9 @@ class RTLSDRThread;
 class RTLSDRInput : public SampleSource {
 public:
 	struct Settings {
+		int m_devSampleRate;
+		quint64 m_centerFrequency;
 		qint32 m_gain;
-		qint32 m_samplerate;
 		qint32 m_loPpmCorrection;
 		quint32 m_log2Decim;
 
@@ -42,21 +43,18 @@ public:
 		MESSAGE_CLASS_DECLARATION
 
 	public:
-		const GeneralSettings& getGeneralSettings() const { return m_generalSettings; }
 		const Settings& getSettings() const { return m_settings; }
 
-		static MsgConfigureRTLSDR* create(const GeneralSettings& generalSettings, const Settings& settings)
+		static MsgConfigureRTLSDR* create(const Settings& settings)
 		{
-			return new MsgConfigureRTLSDR(generalSettings, settings);
+			return new MsgConfigureRTLSDR(settings);
 		}
 
 	private:
-		GeneralSettings m_generalSettings;
 		Settings m_settings;
 
-		MsgConfigureRTLSDR(const GeneralSettings& generalSettings, const Settings& settings) :
+		MsgConfigureRTLSDR(const Settings& settings) :
 			Message(),
-			m_generalSettings(generalSettings),
 			m_settings(settings)
 		{ }
 	};
@@ -81,18 +79,18 @@ public:
 		{ }
 	};
 
-	RTLSDRInput(MessageQueue* msgQueueToGUI);
-	~RTLSDRInput();
+	RTLSDRInput();
+	virtual ~RTLSDRInput();
 
-	bool startInput(int device);
-	void stopInput();
+	virtual bool init(const Message& message);
+	virtual bool start(int device);
+	virtual void stop();
 
-	const QString& getDeviceDescription() const;
-	int getSampleRate() const;
-	quint64 getCenterFrequency() const;
-
-	bool handleMessage(Message* message);
+	virtual const QString& getDeviceDescription() const;
+	virtual int getSampleRate() const;
+	virtual quint64 getCenterFrequency() const;
 
+	virtual bool handleMessage(const Message& message);
 
 	void set_ds_mode(int on);
 
@@ -104,7 +102,7 @@ private:
 	QString m_deviceDescription;
 	std::vector<int> m_gains;
 
-	bool applySettings(const GeneralSettings& generalSettings, const Settings& settings, bool force);
+	bool applySettings(const Settings& settings, bool force);
 };
 
 #endif // INCLUDE_RTLSDRINPUT_H