Deep redesign: phase #4. Compiles

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;
+}
+
+