Source plugins: put a serializer and deserializer in the core plugin for server. NFM demod: fixed deserializer

plugins/channelrx/demodnfm/nfmdemod.cpp

@@ -468,19 +468,22 @@ QByteArray NFMDemod::serialize() const
 
 bool NFMDemod::deserialize(const QByteArray& data)
 {
-    if (m_settings.deserialize(data))
+    bool success = true;
-    {
+
-        MsgConfigureNFMDemod *msg = MsgConfigureNFMDemod::create(m_settings, true);
+    if (!m_settings.deserialize(data))
-        m_inputMessageQueue.push(msg);
-        return true;
-    }
-    else
     {
         m_settings.resetToDefaults();
+        success = false;
+    }
+
+    NFMDemod::MsgConfigureChannelizer* channelConfigMsg = NFMDemod::MsgConfigureChannelizer::create(
+            48000, m_settings.m_inputFrequencyOffset);
+    m_inputMessageQueue.push(channelConfigMsg);
+
     MsgConfigureNFMDemod *msg = MsgConfigureNFMDemod::create(m_settings, true);
     m_inputMessageQueue.push(msg);
-        return false;
+
-    }
+    return success;
 }
 
 int NFMDemod::webapiSettingsGet(

plugins/samplesource/airspy/airspygui.cpp

@@ -119,7 +119,16 @@ bool AirspyGui::deserialize(const QByteArray& data)
 
 bool AirspyGui::handleMessage(const Message& message)
 {
-    if (AirspyInput::MsgStartStop::match(message))
+    if (AirspyInput::MsgConfigureAirspy::match(message))
+    {
+        const AirspyInput::MsgConfigureAirspy& cfg = (AirspyInput::MsgConfigureAirspy&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (AirspyInput::MsgStartStop::match(message))
     {
         AirspyInput::MsgStartStop& notif = (AirspyInput::MsgStartStop&) message;
         blockApplySettings(true);

plugins/samplesource/airspy/airspyinput.cpp

@@ -213,6 +213,33 @@ void AirspyInput::stop()
 	m_running = false;
 }
 
+QByteArray AirspyInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool AirspyInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureAirspy* message = MsgConfigureAirspy::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureAirspy* messageToGUI = MsgConfigureAirspy::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& AirspyInput::getDeviceDescription() const
 {
 	return m_deviceDescription;
@@ -229,6 +256,21 @@ quint64 AirspyInput::getCenterFrequency() const
 	return m_settings.m_centerFrequency;
 }
 
+void AirspyInput::setCenterFrequency(qint64 centerFrequency)
+{
+    AirspySettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureAirspy* message = MsgConfigureAirspy::create(settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureAirspy* messageToGUI = MsgConfigureAirspy::create(settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 bool AirspyInput::handleMessage(const Message& message)
 {
 	if (MsgConfigureAirspy::match(message))
@@ -285,7 +327,7 @@ bool AirspyInput::handleMessage(const Message& message)
 	}
 }
 
-void AirspyInput::setCenterFrequency(quint64 freq_hz)
+void AirspyInput::setDeviceCenterFrequency(quint64 freq_hz)
 {
 	qint64 df = ((qint64)freq_hz * m_settings.m_LOppmTenths) / 10000000LL;
 	freq_hz += df;
@@ -294,11 +336,11 @@ void AirspyInput::setCenterFrequency(quint64 freq_hz)
 
 	if (rc != AIRSPY_SUCCESS)
 	{
-		qWarning("AirspyInput::setCenterFrequency: could not frequency to %llu Hz", freq_hz);
+		qWarning("AirspyInput::setDeviceCenterFrequency: could not frequency to %llu Hz", freq_hz);
 	}
 	else
 	{
-		qWarning("AirspyInput::setCenterFrequency: frequency set to %llu Hz", freq_hz);
+		qWarning("AirspyInput::setDeviceCenterFrequency: frequency set to %llu Hz", freq_hz);
 	}
 }
 
@@ -401,7 +443,7 @@ bool AirspyInput::applySettings(const AirspySettings& settings, bool force)
 
 		if (m_dev != 0)
 		{
-			setCenterFrequency(deviceCenterFrequency);
+			setDeviceCenterFrequency(deviceCenterFrequency);
 
 			qDebug() << "AirspyInput::applySettings: center freq: " << m_settings.m_centerFrequency << " Hz"
 					<< " device center freq: " << deviceCenterFrequency << " Hz"

plugins/samplesource/airspy/airspyinput.h

@@ -17,11 +17,12 @@
 #ifndef INCLUDE_AIRSPYINPUT_H
 #define INCLUDE_AIRSPYINPUT_H
 
-#include <dsp/devicesamplesource.h>
-
-#include "airspysettings.h"
-#include <libairspy/airspy.h>
 #include <QString>
+#include <QByteArray>
+
+#include <libairspy/airspy.h>
+#include <dsp/devicesamplesource.h>
+#include "airspysettings.h"
 
 class DeviceSourceAPI;
 class AirspyThread;
@@ -98,10 +99,14 @@ public:
 	virtual bool start();
 	virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
 	virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
 	virtual const QString& getDeviceDescription() const;
 	virtual int getSampleRate() const;
 	virtual quint64 getCenterFrequency() const;
+	virtual void setCenterFrequency(qint64 centerFrequency);
 	const std::vector<uint32_t>& getSampleRates() const { return m_sampleRates; }
 
 	virtual bool handleMessage(const Message& message);
@@ -123,7 +128,7 @@ private:
 	void closeDevice();
 	bool applySettings(const AirspySettings& settings, bool force);
 	struct airspy_device *open_airspy_from_sequence(int sequence);
-	void setCenterFrequency(quint64 freq);
+	void setDeviceCenterFrequency(quint64 freq);
 
 	DeviceSourceAPI *m_deviceAPI;
 	QMutex m_mutex;

plugins/samplesource/bladerfinput/bladerfinput.cpp

@@ -207,6 +207,33 @@ void BladerfInput::stop()
 	m_running = false;
 }
 
+QByteArray BladerfInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool BladerfInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureBladerf* message = MsgConfigureBladerf::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureBladerf* messageToGUI = MsgConfigureBladerf::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& BladerfInput::getDeviceDescription() const
 {
 	return m_deviceDescription;
@@ -223,6 +250,21 @@ quint64 BladerfInput::getCenterFrequency() const
 	return m_settings.m_centerFrequency;
 }
 
+void BladerfInput::setCenterFrequency(qint64 centerFrequency)
+{
+    BladeRFInputSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureBladerf* message = MsgConfigureBladerf::create(settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureBladerf* messageToGUI = MsgConfigureBladerf::create(settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 bool BladerfInput::handleMessage(const Message& message)
 {
 	if (MsgConfigureBladerf::match(message))

plugins/samplesource/bladerfinput/bladerfinput.h

@@ -17,13 +17,13 @@
 #ifndef INCLUDE_BLADERFINPUT_H
 #define INCLUDE_BLADERFINPUT_H
 
+#include <QString>
+#include <QByteArray>
+
+#include <libbladeRF.h>
 #include <dsp/devicesamplesource.h>
 #include "bladerf/devicebladerf.h"
 #include "bladerf/devicebladerfparam.h"
-
-#include <libbladeRF.h>
-#include <QString>
-
 #include "bladerfinputsettings.h"
 
 class DeviceSourceAPI;
@@ -101,10 +101,14 @@ public:
 	virtual bool start();
 	virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
 	virtual const QString& getDeviceDescription() const;
 	virtual int getSampleRate() const;
 	virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 
 	virtual bool handleMessage(const Message& message);
 

plugins/samplesource/bladerfinput/bladerfinputgui.cpp

@@ -126,7 +126,16 @@ bool BladerfInputGui::deserialize(const QByteArray& data)
 
 bool BladerfInputGui::handleMessage(const Message& message)
 {
-    if (BladerfInput::MsgStartStop::match(message))
+    if (BladerfInput::MsgConfigureBladerf::match(message))
+    {
+        const BladerfInput::MsgConfigureBladerf& cfg = (BladerfInput::MsgConfigureBladerf&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (BladerfInput::MsgStartStop::match(message))
     {
         BladerfInput::MsgStartStop& notif = (BladerfInput::MsgStartStop&) message;
         blockApplySettings(true);

plugins/samplesource/fcdpro/fcdprogui.cpp

@@ -210,7 +210,16 @@ bool FCDProGui::deserialize(const QByteArray& data)
 
 bool FCDProGui::handleMessage(const Message& message __attribute__((unused)))
 {
-    if (FCDProInput::MsgStartStop::match(message))
+    if (FCDProInput::MsgConfigureFCD::match(message))
+    {
+        const FCDProInput::MsgConfigureFCD& cfg = (FCDProInput::MsgConfigureFCD&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (FCDProInput::MsgStartStop::match(message))
     {
         FCDProInput::MsgStartStop& notif = (FCDProInput::MsgStartStop&) message;
         blockApplySettings(true);

plugins/samplesource/fcdpro/fcdproinput.cpp

@@ -163,6 +163,33 @@ void FCDProInput::stop()
 	m_running = false;
 }
 
+QByteArray FCDProInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool FCDProInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureFCD* message = MsgConfigureFCD::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureFCD* messageToGUI = MsgConfigureFCD::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& FCDProInput::getDeviceDescription() const
 {
 	return m_deviceDescription;
@@ -178,6 +205,21 @@ quint64 FCDProInput::getCenterFrequency() const
 	return m_settings.m_centerFrequency;
 }
 
+void FCDProInput::setCenterFrequency(qint64 centerFrequency)
+{
+    FCDProSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureFCD* message = MsgConfigureFCD::create(settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureFCD* messageToGUI = MsgConfigureFCD::create(settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 bool FCDProInput::handleMessage(const Message& message)
 {
 	if(MsgConfigureFCD::match(message))

plugins/samplesource/fcdpro/fcdproinput.h

@@ -18,12 +18,13 @@
 #ifndef INCLUDE_FCDPROINPUT_H
 #define INCLUDE_FCDPROINPUT_H
 
-#include <dsp/devicesamplesource.h>
+#include <QString>
+#include <QByteArray>
+#include <inttypes.h>
 
+#include <dsp/devicesamplesource.h>
 #include "fcdprosettings.h"
 #include "fcdhid.h"
-#include <QString>
-#include <inttypes.h>
 
 struct fcd_buffer {
 	void *start;
@@ -105,10 +106,14 @@ public:
 	virtual bool start();
 	virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
 	virtual const QString& getDeviceDescription() const;
 	virtual int getSampleRate() const;
 	virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 
 	virtual bool handleMessage(const Message& message);
 

plugins/samplesource/fcdproplus/fcdproplusgui.cpp

@@ -128,7 +128,16 @@ bool FCDProPlusGui::deserialize(const QByteArray& data)
 
 bool FCDProPlusGui::handleMessage(const Message& message __attribute__((unused)))
 {
-    if (FCDProPlusInput::MsgStartStop::match(message))
+    if (FCDProPlusInput::MsgConfigureFCD::match(message))
+    {
+        const FCDProPlusInput::MsgConfigureFCD& cfg = (FCDProPlusInput::MsgConfigureFCD&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (FCDProPlusInput::MsgStartStop::match(message))
     {
         FCDProPlusInput::MsgStartStop& notif = (FCDProPlusInput::MsgStartStop&) message;
         blockApplySettings(true);

plugins/samplesource/fcdproplus/fcdproplusinput.cpp

@@ -157,6 +157,33 @@ void FCDProPlusInput::stop()
 	m_running = false;
 }
 
+QByteArray FCDProPlusInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool FCDProPlusInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureFCD* message = MsgConfigureFCD::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureFCD* messageToGUI = MsgConfigureFCD::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& FCDProPlusInput::getDeviceDescription() const
 {
 	return m_deviceDescription;
@@ -172,6 +199,21 @@ quint64 FCDProPlusInput::getCenterFrequency() const
 	return m_settings.m_centerFrequency;
 }
 
+void FCDProPlusInput::setCenterFrequency(qint64 centerFrequency)
+{
+    FCDProPlusSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureFCD* message = MsgConfigureFCD::create(settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureFCD* messageToGUI = MsgConfigureFCD::create(settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 bool FCDProPlusInput::handleMessage(const Message& message)
 {
 	if(MsgConfigureFCD::match(message))

plugins/samplesource/fcdproplus/fcdproplusinput.h

@@ -17,12 +17,13 @@
 #ifndef INCLUDE_FCDINPUT_H
 #define INCLUDE_FCDINPUT_H
 
-#include <dsp/devicesamplesource.h>
+#include <QString>
+#include <QByteArray>
+#include <inttypes.h>
 
+#include <dsp/devicesamplesource.h>
 #include "fcdproplussettings.h"
 #include "fcdhid.h"
-#include <QString>
-#include <inttypes.h>
 
 struct fcd_buffer {
 	void *start;
@@ -104,10 +105,14 @@ public:
 	virtual bool start();
 	virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
 	virtual const QString& getDeviceDescription() const;
 	virtual int getSampleRate() const;
 	virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 
 	virtual bool handleMessage(const Message& message);
 

plugins/samplesource/filesource/filesourcegui.cpp

@@ -156,7 +156,16 @@ void FileSourceGui::handleInputMessages()
 
 bool FileSourceGui::handleMessage(const Message& message)
 {
-	if (FileSourceInput::MsgReportFileSourceAcquisition::match(message))
+    if (FileSourceInput::MsgConfigureFileSource::match(message))
+    {
+        const FileSourceInput::MsgConfigureFileSource& cfg = (FileSourceInput::MsgConfigureFileSource&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (FileSourceInput::MsgReportFileSourceAcquisition::match(message))
 	{
 		m_acquisition = ((FileSourceInput::MsgReportFileSourceAcquisition&)message).getAcquisition();
 		updateWithAcquisition();

plugins/samplesource/filesource/filesourceinput.cpp

@@ -189,6 +189,33 @@ void FileSourceInput::stop()
 	}
 }
 
+QByteArray FileSourceInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool FileSourceInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureFileSource* message = MsgConfigureFileSource::create(m_settings);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureFileSource* messageToGUI = MsgConfigureFileSource::create(m_settings);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& FileSourceInput::getDeviceDescription() const
 {
 	return m_deviceDescription;
@@ -204,6 +231,21 @@ quint64 FileSourceInput::getCenterFrequency() const
 	return m_centerFrequency;
 }
 
+void FileSourceInput::setCenterFrequency(qint64 centerFrequency)
+{
+    FileSourceSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureFileSource* message = MsgConfigureFileSource::create(m_settings);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureFileSource* messageToGUI = MsgConfigureFileSource::create(m_settings);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 std::time_t FileSourceInput::getStartingTimeStamp() const
 {
 	return m_startingTimeStamp;

plugins/samplesource/filesource/filesourceinput.h

@@ -17,13 +17,14 @@
 #ifndef INCLUDE_FILESOURCEINPUT_H
 #define INCLUDE_FILESOURCEINPUT_H
 
-#include <dsp/devicesamplesource.h>
 #include <QString>
+#include <QByteArray>
 #include <QTimer>
 #include <ctime>
 #include <iostream>
 #include <fstream>
 
+#include <dsp/devicesamplesource.h>
 #include "filesourcesettings.h"
 
 class FileSourceThread;
@@ -230,10 +231,14 @@ public:
 	virtual bool start();
 	virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
 	virtual const QString& getDeviceDescription() const;
 	virtual int getSampleRate() const;
 	virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 	std::time_t getStartingTimeStamp() const;
 
 	virtual bool handleMessage(const Message& message);

plugins/samplesource/hackrfinput/hackrfinput.cpp

@@ -188,6 +188,33 @@ void HackRFInput::stop()
 	m_running = false;
 }
 
+QByteArray HackRFInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool HackRFInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureHackRF* message = MsgConfigureHackRF::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureHackRF* messageToGUI = MsgConfigureHackRF::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& HackRFInput::getDeviceDescription() const
 {
 	return m_deviceDescription;
@@ -203,6 +230,21 @@ quint64 HackRFInput::getCenterFrequency() const
 	return m_settings.m_centerFrequency;
 }
 
+void HackRFInput::setCenterFrequency(qint64 centerFrequency)
+{
+    HackRFInputSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureHackRF* message = MsgConfigureHackRF::create(settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureHackRF* messageToGUI = MsgConfigureHackRF::create(settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 bool HackRFInput::handleMessage(const Message& message)
 {
 	if (MsgConfigureHackRF::match(message))

plugins/samplesource/hackrfinput/hackrfinput.h

@@ -17,10 +17,11 @@
 #ifndef INCLUDE_HACKRFINPUT_H
 #define INCLUDE_HACKRFINPUT_H
 
-#include <dsp/devicesamplesource.h>
-#include "libhackrf/hackrf.h"
 #include <QString>
+#include <QByteArray>
 
+#include "libhackrf/hackrf.h"
+#include <dsp/devicesamplesource.h>
 #include "hackrf/devicehackrf.h"
 #include "hackrf/devicehackrfparam.h"
 #include "hackrfinputsettings.h"
@@ -118,10 +119,14 @@ public:
 	virtual bool start();
 	virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
 	virtual const QString& getDeviceDescription() const;
 	virtual int getSampleRate() const;
 	virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 
 	virtual bool handleMessage(const Message& message);
 

plugins/samplesource/hackrfinput/hackrfinputgui.cpp

@@ -125,7 +125,16 @@ bool HackRFInputGui::deserialize(const QByteArray& data)
 
 bool HackRFInputGui::handleMessage(const Message& message)
 {
-    if (HackRFInput::MsgReportHackRF::match(message))
+    if (HackRFInput::MsgConfigureHackRF::match(message))
+    {
+        const HackRFInput::MsgConfigureHackRF& cfg = (HackRFInput::MsgConfigureHackRF&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (HackRFInput::MsgReportHackRF::match(message))
     {
         displaySettings();
         return true;

plugins/samplesource/limesdrinput/limesdrinput.cpp

@@ -425,6 +425,33 @@ void LimeSDRInput::stop()
     releaseChannel();
 }
 
+QByteArray LimeSDRInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool LimeSDRInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureLimeSDR* message = MsgConfigureLimeSDR::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureLimeSDR* messageToGUI = MsgConfigureLimeSDR::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& LimeSDRInput::getDeviceDescription() const
 {
     return m_deviceDescription;
@@ -441,6 +468,21 @@ quint64 LimeSDRInput::getCenterFrequency() const
     return m_settings.m_centerFrequency;
 }
 
+void LimeSDRInput::setCenterFrequency(qint64 centerFrequency)
+{
+    LimeSDRInputSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureLimeSDR* message = MsgConfigureLimeSDR::create(settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureLimeSDR* messageToGUI = MsgConfigureLimeSDR::create(settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 std::size_t LimeSDRInput::getChannelIndex()
 {
     return m_deviceShared.m_channel;

plugins/samplesource/limesdrinput/limesdrinput.h

@@ -18,6 +18,7 @@
 #define PLUGINS_SAMPLESOURCE_LIMESDRINPUT_LIMESDRINPUT_H_
 
 #include <QString>
+#include <QByteArray>
 #include <stdint.h>
 
 #include "dsp/devicesamplesource.h"
@@ -212,10 +213,14 @@ public:
     virtual bool start();
     virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
     virtual const QString& getDeviceDescription() const;
     virtual int getSampleRate() const;
     virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 
     virtual bool handleMessage(const Message& message);
 

plugins/samplesource/limesdrinput/limesdrinputgui.cpp

@@ -140,8 +140,16 @@ bool LimeSDRInputGUI::deserialize(const QByteArray& data)
 
 bool LimeSDRInputGUI::handleMessage(const Message& message)
 {
-
+    if (LimeSDRInput::MsgConfigureLimeSDR::match(message))
-    if (DeviceLimeSDRShared::MsgReportBuddyChange::match(message))
+    {
+        const LimeSDRInput::MsgConfigureLimeSDR& cfg = (LimeSDRInput::MsgConfigureLimeSDR&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (DeviceLimeSDRShared::MsgReportBuddyChange::match(message))
     {
         DeviceLimeSDRShared::MsgReportBuddyChange& report = (DeviceLimeSDRShared::MsgReportBuddyChange&) message;
         m_settings.m_devSampleRate = report.getDevSampleRate();

plugins/samplesource/plutosdrinput/plutosdrinput.cpp

@@ -118,6 +118,33 @@ void PlutoSDRInput::stop()
     m_running = false;
 }
 
+QByteArray PlutoSDRInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool PlutoSDRInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigurePlutoSDR* message = MsgConfigurePlutoSDR::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigurePlutoSDR* messageToGUI = MsgConfigurePlutoSDR::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& PlutoSDRInput::getDeviceDescription() const
 {
     return m_deviceDescription;
@@ -132,6 +159,20 @@ quint64 PlutoSDRInput::getCenterFrequency() const
     return m_settings.m_centerFrequency;
 }
 
+void PlutoSDRInput::setCenterFrequency(qint64 centerFrequency)
+{
+    PlutoSDRInputSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigurePlutoSDR* message = MsgConfigurePlutoSDR::create(m_settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigurePlutoSDR* messageToGUI = MsgConfigurePlutoSDR::create(m_settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
 
 bool PlutoSDRInput::handleMessage(const Message& message)
 {

plugins/samplesource/plutosdrinput/plutosdrinput.h

@@ -18,6 +18,7 @@
 #define PLUGINS_SAMPLESOURCE_PLUTOSDRINPUT_PLUTOSDRINPUT_H_
 
 #include <QString>
+#include <QByteArray>
 
 #include "iio.h"
 #include <dsp/devicesamplesource.h>
@@ -100,10 +101,14 @@ public:
     virtual bool start();
     virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
     virtual const QString& getDeviceDescription() const;
     virtual int getSampleRate() const;
     virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 
     virtual bool handleMessage(const Message& message);
 

plugins/samplesource/plutosdrinput/plutosdrinputgui.cpp

@@ -131,7 +131,16 @@ bool PlutoSDRInputGui::deserialize(const QByteArray& data)
 
 bool PlutoSDRInputGui::handleMessage(const Message& message __attribute__((unused)))
 {
-    if (PlutoSDRInput::MsgStartStop::match(message))
+    if (PlutoSDRInput::MsgConfigurePlutoSDR::match(message))
+    {
+        const PlutoSDRInput::MsgConfigurePlutoSDR& cfg = (PlutoSDRInput::MsgConfigurePlutoSDR&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (PlutoSDRInput::MsgStartStop::match(message))
     {
         PlutoSDRInput::MsgStartStop& notif = (PlutoSDRInput::MsgStartStop&) message;
         blockApplySettings(true);

plugins/samplesource/rtlsdr/rtlsdrgui.cpp

@@ -146,7 +146,7 @@ bool RTLSDRGui::handleMessage(const Message& message)
 	    blockApplySettings(false);
 	    return true;
 	}
-    if (RTLSDRInput::MsgStartStop::match(message))
+	else if (RTLSDRInput::MsgStartStop::match(message))
     {
         RTLSDRInput::MsgStartStop& notif = (RTLSDRInput::MsgStartStop&) message;
         blockApplySettings(true);

plugins/samplesource/rtlsdr/rtlsdrinput.cpp

@@ -234,6 +234,33 @@ void RTLSDRInput::stop()
 	m_running = false;
 }
 
+QByteArray RTLSDRInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool RTLSDRInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureRTLSDR* message = MsgConfigureRTLSDR::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureRTLSDR* messageToGUI = MsgConfigureRTLSDR::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& RTLSDRInput::getDeviceDescription() const
 {
 	return m_deviceDescription;
@@ -250,6 +277,21 @@ quint64 RTLSDRInput::getCenterFrequency() const
 	return m_settings.m_centerFrequency;
 }
 
+void RTLSDRInput::setCenterFrequency(qint64 centerFrequency)
+{
+    RTLSDRSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureRTLSDR* message = MsgConfigureRTLSDR::create(settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureRTLSDR* messageToGUI = MsgConfigureRTLSDR::create(settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 bool RTLSDRInput::handleMessage(const Message& message)
 {
     if (MsgConfigureRTLSDR::match(message))

plugins/samplesource/rtlsdr/rtlsdrinput.h

@@ -18,11 +18,12 @@
 #ifndef INCLUDE_RTLSDRINPUT_H
 #define INCLUDE_RTLSDRINPUT_H
 
-#include <dsp/devicesamplesource.h>
+#include <QString>
+#include <QByteArray>
 
+#include <dsp/devicesamplesource.h>
 #include "rtlsdrsettings.h"
 #include <rtl-sdr.h>
-#include <QString>
 
 class DeviceSourceAPI;
 class RTLSDRThread;
@@ -99,10 +100,14 @@ public:
 	virtual bool start();
 	virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
 	virtual const QString& getDeviceDescription() const;
 	virtual int getSampleRate() const;
 	virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 
 	virtual bool handleMessage(const Message& message);
 

plugins/samplesource/sdrdaemonsource/sdrdaemonsourcegui.cpp

@@ -176,7 +176,16 @@ void SDRdaemonSourceGui::setCenterFrequency(qint64 centerFrequency)
 
 bool SDRdaemonSourceGui::handleMessage(const Message& message)
 {
-	if (SDRdaemonSourceInput::MsgReportSDRdaemonAcquisition::match(message))
+    if (SDRdaemonSourceInput::MsgConfigureSDRdaemonSource::match(message))
+    {
+        const SDRdaemonSourceInput::MsgConfigureSDRdaemonSource& cfg = (SDRdaemonSourceInput::MsgConfigureSDRdaemonSource&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (SDRdaemonSourceInput::MsgReportSDRdaemonAcquisition::match(message))
 	{
 		m_acquisition = ((SDRdaemonSourceInput::MsgReportSDRdaemonAcquisition&)message).getAcquisition();
 		updateWithAcquisition();

plugins/samplesource/sdrdaemonsource/sdrdaemonsourceinput.cpp

@@ -102,6 +102,33 @@ void SDRdaemonSourceInput::stop()
     m_SDRdaemonUDPHandler->stop();
 }
 
+QByteArray SDRdaemonSourceInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool SDRdaemonSourceInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureSDRdaemonSource* message = MsgConfigureSDRdaemonSource::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureSDRdaemonSource* messageToGUI = MsgConfigureSDRdaemonSource::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 void SDRdaemonSourceInput::setMessageQueueToGUI(MessageQueue *queue)
 {
     m_guiMessageQueue = queue;
@@ -131,6 +158,15 @@ quint64 SDRdaemonSourceInput::getCenterFrequency() const
     }
 }
 
+void SDRdaemonSourceInput::setCenterFrequency(qint64 centerFrequency)
+{
+    SDRdaemonSourceSettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureSDRdaemonSource* message = MsgConfigureSDRdaemonSource::create(m_settings, false);
+    m_inputMessageQueue.push(message);
+}
+
 std::time_t SDRdaemonSourceInput::getStartingTimeStamp() const
 {
 	return m_startingTimeStamp;

plugins/samplesource/sdrdaemonsource/sdrdaemonsourceinput.h

@@ -17,13 +17,14 @@
 #ifndef INCLUDE_SDRDAEMONSOURCEINPUT_H
 #define INCLUDE_SDRDAEMONSOURCEINPUT_H
 
-#include <dsp/devicesamplesource.h>
 #include <QString>
+#include <QByteArray>
 #include <QTimer>
 #include <ctime>
 #include <iostream>
 #include <stdint.h>
 
+#include <dsp/devicesamplesource.h>
 #include "sdrdaemonsourcesettings.h"
 
 class DeviceSourceAPI;
@@ -265,10 +266,14 @@ public:
 	virtual bool start();
 	virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue);
 	virtual const QString& getDeviceDescription() const;
 	virtual int getSampleRate() const;
 	virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 	std::time_t getStartingTimeStamp() const;
 	bool isStreaming() const;
 

plugins/samplesource/sdrplay/sdrplaygui.cpp

@@ -137,7 +137,16 @@ bool SDRPlayGui::deserialize(const QByteArray& data)
 
 bool SDRPlayGui::handleMessage(const Message& message)
 {
-    if (SDRPlayInput::MsgReportSDRPlayGains::match(message))
+    if (SDRPlayInput::MsgConfigureSDRPlay::match(message))
+    {
+        const SDRPlayInput::MsgConfigureSDRPlay& cfg = (SDRPlayInput::MsgConfigureSDRPlay&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (SDRPlayInput::MsgReportSDRPlayGains::match(message))
     {
     	qDebug() << "SDRPlayGui::handleMessage: MsgReportSDRPlayGains";
 

plugins/samplesource/sdrplay/sdrplayinput.cpp

@@ -217,6 +217,33 @@ void SDRPlayInput::stop()
     m_running = false;
 }
 
+QByteArray SDRPlayInput::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool SDRPlayInput::deserialize(const QByteArray& data)
+{
+    bool success = true;
+
+    if (!m_settings.deserialize(data))
+    {
+        m_settings.resetToDefaults();
+        success = false;
+    }
+
+    MsgConfigureSDRPlay* message = MsgConfigureSDRPlay::create(m_settings, true);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureSDRPlay* messageToGUI = MsgConfigureSDRPlay::create(m_settings, true);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+
+    return success;
+}
+
 const QString& SDRPlayInput::getDeviceDescription() const
 {
     return m_deviceDescription;
@@ -233,6 +260,21 @@ quint64 SDRPlayInput::getCenterFrequency() const
     return m_settings.m_centerFrequency;
 }
 
+void SDRPlayInput::setCenterFrequency(qint64 centerFrequency)
+{
+    SDRPlaySettings settings = m_settings;
+    settings.m_centerFrequency = centerFrequency;
+
+    MsgConfigureSDRPlay* message = MsgConfigureSDRPlay::create(settings, false);
+    m_inputMessageQueue.push(message);
+
+    if (m_guiMessageQueue)
+    {
+        MsgConfigureSDRPlay* messageToGUI = MsgConfigureSDRPlay::create(settings, false);
+        m_guiMessageQueue->push(messageToGUI);
+    }
+}
+
 bool SDRPlayInput::handleMessage(const Message& message)
 {
     if (MsgConfigureSDRPlay::match(message))
@@ -517,7 +559,7 @@ bool SDRPlayInput::applySettings(const SDRPlaySettings& settings, bool forwardCh
 
         if(m_dev != 0)
         {
-            if (setCenterFrequency(deviceCenterFrequency))
+            if (setDeviceCenterFrequency(deviceCenterFrequency))
             {
                 qDebug() << "SDRPlayInput::applySettings: center freq: " << m_settings.m_centerFrequency << " Hz"
                         << " device center freq: " << deviceCenterFrequency << " Hz"
@@ -588,7 +630,7 @@ bool SDRPlayInput::applySettings(const SDRPlaySettings& settings, bool forwardCh
     return true;
 }
 
-bool SDRPlayInput::setCenterFrequency(quint64 freq_hz)
+bool SDRPlayInput::setDeviceCenterFrequency(quint64 freq_hz)
 {
     qint64 df = ((qint64)freq_hz * m_settings.m_LOppmTenths) / 10000000LL;
     freq_hz += df;
@@ -597,12 +639,12 @@ bool SDRPlayInput::setCenterFrequency(quint64 freq_hz)
 
     if (r != 0)
     {
-        qWarning("SDRPlayInput::setCenterFrequency: could not frequency to %llu Hz", freq_hz);
+        qWarning("SDRPlayInput::setDeviceCenterFrequency: could not frequency to %llu Hz", freq_hz);
         return false;
     }
     else
     {
-        qWarning("SDRPlayInput::setCenterFrequency: frequency set to %llu Hz", freq_hz);
+        qWarning("SDRPlayInput::setDeviceCenterFrequency: frequency set to %llu Hz", freq_hz);
         return true;
     }
 }

plugins/samplesource/sdrplay/sdrplayinput.h

@@ -17,13 +17,14 @@
 #ifndef PLUGINS_SAMPLESOURCE_SDRPLAY_SDRPLAYINPUT_H_
 #define PLUGINS_SAMPLESOURCE_SDRPLAY_SDRPLAYINPUT_H_
 
-#include <dsp/devicesamplesource.h>
-
-#include "sdrplaysettings.h"
-#include <mirisdr.h>
 #include <QString>
+#include <QByteArray>
 #include <stdint.h>
 
+#include <mirisdr.h>
+#include <dsp/devicesamplesource.h>
+#include "sdrplaysettings.h"
+
 class DeviceSourceAPI;
 class SDRPlayThread;
 class FileRecord;
@@ -136,10 +137,14 @@ public:
     virtual bool start();
     virtual void stop();
 
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
     virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
     virtual const QString& getDeviceDescription() const;
     virtual int getSampleRate() const;
     virtual quint64 getCenterFrequency() const;
+    virtual void setCenterFrequency(qint64 centerFrequency);
 
     virtual bool handleMessage(const Message& message);
 
@@ -158,7 +163,7 @@ private:
     bool openDevice();
     void closeDevice();
     bool applySettings(const SDRPlaySettings& settings, bool forwardChange, bool force);
-    bool setCenterFrequency(quint64 freq);
+    bool setDeviceCenterFrequency(quint64 freq);
 
     DeviceSourceAPI *m_deviceAPI;
     QMutex m_mutex;

sdrbase/device/devicesourceapi.cpp

@@ -243,24 +243,29 @@ void DeviceSourceAPI::loadSourceSettings(const Preset* preset)
     {
         qDebug("DeviceSourceAPI::loadSourceSettings: Loading preset [%s | %s]", qPrintable(preset->getGroup()), qPrintable(preset->getDescription()));
 
-        if(m_sampleSourcePluginInstanceUI != 0)
-        {
         const QByteArray* sourceConfig = preset->findBestDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence);
+        qint64 centerFrequency = preset->getCenterFrequency();
+        qDebug("DeviceSourceAPI::loadSettings: center frequency: %llu Hz", centerFrequency);
 
         if (sourceConfig != 0)
         {
             qDebug("DeviceSourceAPI::loadSettings: deserializing source %s[%d]: %s", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
+
+            if (m_sampleSourcePluginInstanceUI != 0)
+            {
                 m_sampleSourcePluginInstanceUI->deserialize(*sourceConfig);
+                m_sampleSourcePluginInstanceUI->setCenterFrequency(centerFrequency);
+            }
+            else
+            {
+                m_deviceSourceEngine->getSource()->deserialize(*sourceConfig);
+                m_deviceSourceEngine->getSource()->setCenterFrequency(centerFrequency);
+            }
         }
         else
         {
             qDebug("DeviceSourceAPI::loadSettings: source %s[%d]: %s not found", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
         }
-
-            qint64 centerFrequency = preset->getCenterFrequency();
-            qDebug("DeviceSourceAPI::loadSettings: center frequency: %llu Hz", centerFrequency);
-            m_sampleSourcePluginInstanceUI->setCenterFrequency(centerFrequency);
-        }
     }
     else
     {
@@ -271,16 +276,18 @@ void DeviceSourceAPI::loadSourceSettings(const Preset* preset)
 void DeviceSourceAPI::saveSourceSettings(Preset* preset)
 {
     if (preset->isSourcePreset())
-    {
-        if(m_sampleSourcePluginInstanceUI != NULL)
     {
         qDebug("DeviceSourceAPI::saveSourceSettings: %s saved", qPrintable(m_sampleSourcePluginInstanceUI->getName()));
+
+        if (m_sampleSourcePluginInstanceUI != 0)
+        {
             preset->addOrUpdateDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence, m_sampleSourcePluginInstanceUI->serialize());
             preset->setCenterFrequency(m_sampleSourcePluginInstanceUI->getCenterFrequency());
         }
         else
         {
-            qDebug("DeviceSourceAPI::saveSourceSettings: no source");
+            preset->addOrUpdateDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence, m_deviceSourceEngine->getSource()->serialize());
+            preset->setCenterFrequency(m_deviceSourceEngine->getSource()->getCenterFrequency());
         }
     }
     else

sdrbase/dsp/devicesamplesource.h

@@ -19,6 +19,7 @@
 #define INCLUDE_SAMPLESOURCE_H
 
 #include <QtGlobal>
+#include <QByteArray>
 
 #include "samplesinkfifo.h"
 #include "util/message.h"
@@ -42,9 +43,13 @@ public:
 	virtual bool start() = 0;
 	virtual void stop() = 0;
 
+    virtual QByteArray serialize() const = 0;
+    virtual bool deserialize(const QByteArray& data) = 0;
+
 	virtual const QString& getDeviceDescription() const = 0;
 	virtual int getSampleRate() const = 0; //!< Sample rate exposed by the source
 	virtual quint64 getCenterFrequency() const = 0; //!< Center frequency exposed by the source
+    virtual void setCenterFrequency(qint64 centerFrequency) = 0;
 
 	virtual bool handleMessage(const Message& message) = 0;