diff --git a/plugins/channelrx/chanalyzerng/CMakeLists.txt b/plugins/channelrx/chanalyzerng/CMakeLists.txt
index 773912188..e3d9f3c75 100644
--- a/plugins/channelrx/chanalyzerng/CMakeLists.txt
+++ b/plugins/channelrx/chanalyzerng/CMakeLists.txt
@@ -4,12 +4,14 @@ set(chanalyzerng_SOURCES
 	chanalyzerng.cpp
 	chanalyzernggui.cpp
 	chanalyzerngplugin.cpp
+	chanalyzerngsettings.cpp
 )
 
 set(chanalyzerng_HEADERS
 	chanalyzerng.h
 	chanalyzernggui.h
 	chanalyzerngplugin.h
+	chanalyzerngsettings.h
 )
 
 set(chanalyzerng_FORMS
diff --git a/plugins/channelrx/chanalyzerng/chanalyzerng.cpp b/plugins/channelrx/chanalyzerng/chanalyzerng.cpp
index 19ee567bf..f66c44e85 100644
--- a/plugins/channelrx/chanalyzerng/chanalyzerng.cpp
+++ b/plugins/channelrx/chanalyzerng/chanalyzerng.cpp
@@ -26,6 +26,7 @@
 #include "dsp/downchannelizer.h"
 
 MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelAnalyzer, Message)
+MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelAnalyzerOld, Message)
 MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelizer, Message)
 MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgReportChannelSampleRateChanged, Message)
 
@@ -81,7 +82,7 @@ void ChannelAnalyzerNG::configure(MessageQueue* messageQueue,
 		bool fll,
 		unsigned int pllPskOrder)
 {
-    Message* cmd = MsgConfigureChannelAnalyzer::create(channelSampleRate, Bandwidth, LowCutoff, spanLog2, ssb, pll, fll, pllPskOrder);
+    Message* cmd = MsgConfigureChannelAnalyzerOld::create(channelSampleRate, Bandwidth, LowCutoff, spanLog2, ssb, pll, fll, pllPskOrder);
 	messageQueue->push(cmd);
 }
 
@@ -162,9 +163,9 @@ bool ChannelAnalyzerNG::handleMessage(const Message& cmd)
         cfg.getCenterFrequency());
         return true;
     }
-	else if (MsgConfigureChannelAnalyzer::match(cmd))
+	else if (MsgConfigureChannelAnalyzerOld::match(cmd))
 	{
-		MsgConfigureChannelAnalyzer& cfg = (MsgConfigureChannelAnalyzer&) cmd;
+		MsgConfigureChannelAnalyzerOld& cfg = (MsgConfigureChannelAnalyzerOld&) cmd;
 
         m_config.m_channelSampleRate = cfg.getChannelSampleRate();
 		m_config.m_Bandwidth = cfg.getBandwidth();
@@ -300,3 +301,127 @@ void ChannelAnalyzerNG::apply(bool force)
     m_running.m_pllPskOrder = m_config.m_pllPskOrder;
     //m_settingsMutex.unlock();
 }
+
+void ChannelAnalyzerNG::applyChannelSettings(int inputSampleRate, int inputFrequencyOffset, bool force)
+{
+    qDebug() << "ChannelAnalyzerNG::applyChannelSettings:"
+            << " inputSampleRate: " << inputSampleRate
+            << " inputFrequencyOffset: " << inputFrequencyOffset;
+
+    if ((m_inputFrequencyOffset != inputFrequencyOffset) ||
+        (m_inputSampleRate != inputSampleRate) || force)
+    {
+        m_nco.setFreq(-inputFrequencyOffset, inputSampleRate);
+    }
+
+    if ((m_inputSampleRate != inputSampleRate) || force)
+    {
+        m_settingsMutex.lock();
+
+        m_interpolator.create(16, inputSampleRate, inputSampleRate / 2.2f);
+        m_interpolatorDistanceRemain = 0;
+        m_interpolatorDistance = (Real) inputSampleRate / (Real) m_settings.m_downSampleRate;
+
+        if (!m_settings.m_downSample)
+        {
+            setFilters(inputSampleRate, m_settings.m_bandwidth, m_settings.m_lowCutoff);
+            m_pll.setSampleRate(inputSampleRate / (1<<m_settings.m_spanLog2));
+            m_fll.setSampleRate(inputSampleRate / (1<<m_settings.m_spanLog2));
+        }
+
+        m_settingsMutex.unlock();
+    }
+
+    m_inputSampleRate = inputSampleRate;
+    m_inputFrequencyOffset = inputFrequencyOffset;
+}
+
+void ChannelAnalyzerNG::setFilters(int sampleRate, float bandwidth, float lowCutoff)
+{
+    if (bandwidth < 0)
+    {
+        bandwidth = -bandwidth;
+        lowCutoff = -lowCutoff;
+        m_usb = false;
+    }
+    else
+    {
+        m_usb = true;
+    }
+
+    if (bandwidth < 100.0f)
+    {
+        bandwidth = 100.0f;
+        lowCutoff = 0;
+    }
+
+    SSBFilter->create_filter(lowCutoff / sampleRate, bandwidth / sampleRate);
+    DSBFilter->create_dsb_filter(bandwidth / sampleRate);
+}
+
+void ChannelAnalyzerNG::applySettings(const ChannelAnalyzerNGSettings& settings, bool force)
+{
+    if ((settings.m_downSampleRate != m_settings.m_downSampleRate) || force)
+    {
+        m_settingsMutex.lock();
+        m_interpolator.create(16, m_inputSampleRate, m_inputSampleRate / 2.2);
+        m_interpolatorDistanceRemain = 0.0f;
+        m_interpolatorDistance =  (Real) m_inputSampleRate / (Real) settings.m_downSampleRate;
+        m_settingsMutex.unlock();
+    }
+
+    if ((settings.m_downSample != m_settings.m_downSample) || force)
+    {
+        m_settingsMutex.lock();
+        m_useInterpolator = settings.m_downSample;
+
+        if (settings.m_downSample)
+        {
+            setFilters(settings.m_downSampleRate, settings.m_bandwidth, settings.m_lowCutoff);
+            m_pll.setSampleRate(settings.m_downSampleRate / (1<<settings.m_spanLog2));
+            m_fll.setSampleRate(settings.m_downSampleRate / (1<<settings.m_spanLog2));
+        }
+
+        m_settingsMutex.unlock();
+    }
+
+    if ((settings.m_bandwidth != m_settings.m_bandwidth) ||
+        (settings.m_lowCutoff != m_settings.m_lowCutoff)|| force)
+    {
+        m_settingsMutex.lock();
+        setFilters(settings.m_downSample ? settings.m_downSampleRate : m_inputSampleRate, settings.m_bandwidth, settings.m_lowCutoff);
+        m_settingsMutex.unlock();
+    }
+
+    if ((settings.m_spanLog2 != m_settings.m_spanLog2) || force)
+    {
+        int sampleRate = (settings.m_downSample ? settings.m_downSampleRate : m_inputSampleRate) / (1<<m_running.m_spanLog2);
+        m_pll.setSampleRate(sampleRate);
+        m_fll.setSampleRate(sampleRate);
+    }
+
+    if (settings.m_pll != m_settings.m_pll || force)
+    {
+        if (settings.m_pll)
+        {
+            m_pll.reset();
+            m_fll.reset();
+        }
+    }
+
+    if (settings.m_fll != m_settings.m_fll || force)
+    {
+        if (settings.m_fll) {
+            m_fll.reset();
+        }
+    }
+
+    if (settings.m_pllPskOrder != m_settings.m_pllPskOrder || force)
+    {
+        if (settings.m_pllPskOrder < 32) {
+            m_pll.setPskOrder(settings.m_pllPskOrder);
+        }
+    }
+
+    m_settings = settings;
+}
diff --git a/plugins/channelrx/chanalyzerng/chanalyzerng.h b/plugins/channelrx/chanalyzerng/chanalyzerng.h
index 770fdbd96..58d3d8738 100644
--- a/plugins/channelrx/chanalyzerng/chanalyzerng.h
+++ b/plugins/channelrx/chanalyzerng/chanalyzerng.h
@@ -30,6 +30,8 @@
 #include "audio/audiofifo.h"
 #include "util/message.h"
 
+#include "chanalyzerngsettings.h"
+
 #define ssbFftLen 1024
 
 class DeviceSourceAPI;
@@ -41,6 +43,29 @@ public:
     class MsgConfigureChannelAnalyzer : public Message {
         MESSAGE_CLASS_DECLARATION
 
+    public:
+        const ChannelAnalyzerNGSettings& getSettings() const { return m_settings; }
+        bool getForce() const { return m_force; }
+
+        static MsgConfigureChannelAnalyzer* create(const ChannelAnalyzerNGSettings& settings, bool force)
+        {
+            return new MsgConfigureChannelAnalyzer(settings, force);
+        }
+
+    private:
+        ChannelAnalyzerNGSettings m_settings;
+        bool m_force;
+
+        MsgConfigureChannelAnalyzer(const ChannelAnalyzerNGSettings& settings, bool force) :
+            Message(),
+            m_settings(settings),
+            m_force(force)
+        { }
+    };
+
+    class MsgConfigureChannelAnalyzerOld : public Message {
+        MESSAGE_CLASS_DECLARATION
+
     public:
         int  getChannelSampleRate() const { return m_channelSampleRate; }
         Real getBandwidth() const { return m_Bandwidth; }
@@ -51,7 +76,7 @@ public:
         bool getFLL() const { return m_fll; }
         unsigned int getPLLPSKOrder() const { return m_pllPskOrder; }
 
-        static MsgConfigureChannelAnalyzer* create(
+        static MsgConfigureChannelAnalyzerOld* create(
                 int channelSampleRate,
                 Real Bandwidth,
                 Real LowCutoff,
@@ -61,7 +86,7 @@ public:
                 bool fll,
 				unsigned int pllPskOrder)
         {
-            return new MsgConfigureChannelAnalyzer(
+            return new MsgConfigureChannelAnalyzerOld(
                     channelSampleRate,
                     Bandwidth,
                     LowCutoff,
@@ -82,7 +107,7 @@ public:
         bool m_fll;
         unsigned int m_pllPskOrder;
 
-        MsgConfigureChannelAnalyzer(
+        MsgConfigureChannelAnalyzerOld(
                 int channelSampleRate,
                 Real Bandwidth,
                 Real LowCutoff,
@@ -217,7 +242,10 @@ private:
 	DeviceSourceAPI *m_deviceAPI;
     ThreadedBasebandSampleSink* m_threadedChannelizer;
     DownChannelizer* m_channelizer;
+    ChannelAnalyzerNGSettings m_settings;
 
+    int m_inputSampleRate;
+    int m_inputFrequencyOffset;
 	int m_undersampleCount;
 	fftfilt::cmplx m_sum;
 	bool m_usb;
@@ -239,6 +267,9 @@ private:
 	QMutex m_settingsMutex;
 
 	void apply(bool force = false);
+	void applyChannelSettings(int inputSampleRate, int inputFrequencyOffset, bool force);
+	void applySettings(const ChannelAnalyzerNGSettings& settings, bool force = false);
+	void setFilters(int sampleRate, float bandwidth, float lowCutoff);
 
 	void processOneSample(Complex& c, fftfilt::cmplx *sideband)
 	{
diff --git a/plugins/channelrx/chanalyzerng/chanalyzerngsettings.cpp b/plugins/channelrx/chanalyzerng/chanalyzerngsettings.cpp
new file mode 100644
index 000000000..5873cf0f2
--- /dev/null
+++ b/plugins/channelrx/chanalyzerng/chanalyzerngsettings.cpp
@@ -0,0 +1,110 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2018 Edouard Griffiths, F4EXB.                                  //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <QColor>
+
+#include "dsp/dspengine.h"
+#include "util/simpleserializer.h"
+#include "settings/serializable.h"
+#include "chanalyzerngsettings.h"
+
+ChannelAnalyzerNGSettings::ChannelAnalyzerNGSettings() :
+    m_channelMarker(0)
+{
+    resetToDefaults();
+}
+
+void ChannelAnalyzerNGSettings::resetToDefaults()
+{
+    m_frequency = 0;
+    m_downSample = false;
+    m_downSampleRate = 0;
+    m_bandwidth = 5000;
+    m_lowCutoff = 300;
+    m_spanLog2 = 3;
+    m_ssb = false;
+    m_pll = false;
+    m_fll = false;
+    m_pllPskOrder = 1;
+}
+
+QByteArray ChannelAnalyzerNGSettings::serialize() const
+{
+    SimpleSerializer s(1);
+
+    s.writeS32(1, m_frequency);
+    s.writeS32(2, m_bandwidth);
+    s.writeBlob(3, m_spectrumGUI->serialize());
+    s.writeU32(4, m_rgbColor);
+    s.writeS32(5, m_lowCutoff);
+    s.writeS32(6, m_spanLog2);
+    s.writeBool(7, m_ssb);
+    s.writeBlob(8, m_scopeGUI->serialize());
+    s.writeBool(9, m_downSample);
+    s.writeU32(10, m_downSampleRate);
+    s.writeBool(11, m_pll);
+    s.writeBool(12, m_fll);
+    s.writeU32(13, m_pllPskOrder);
+
+    return s.final();
+}
+
+bool ChannelAnalyzerNGSettings::deserialize(const QByteArray& data)
+{
+    SimpleDeserializer d(data);
+
+    if(!d.isValid())
+    {
+        resetToDefaults();
+        return false;
+    }
+
+    if(d.getVersion() == 1)
+    {
+        QByteArray bytetmp;
+
+        d.readS32(1, &m_frequency, 0);
+        d.readS32(2, &m_bandwidth, 5000);
+
+        if (m_spectrumGUI) {
+            d.readBlob(3, &bytetmp);
+            m_spectrumGUI->deserialize(bytetmp);
+        }
+
+        d.readU32(4, &m_rgbColor);
+        d.readS32(5, &m_lowCutoff, 3);
+        d.readS32(6, &m_spanLog2, 3);
+        d.readBool(7, &m_ssb, false);
+
+        if (m_scopeGUI) {
+            d.readBlob(8, &bytetmp);
+            m_scopeGUI->deserialize(bytetmp);
+        }
+
+        d.readBool(9, &m_downSample, false);
+        d.readU32(10, &m_downSampleRate, 2000U);
+        d.readBool(11, &m_pll, false);
+        d.readBool(12, &m_fll, false);
+        d.readU32(13, &m_pllPskOrder, 1);
+
+        return true;
+    }
+    else
+    {
+        resetToDefaults();
+        return false;
+    }
+}
diff --git a/plugins/channelrx/chanalyzerng/chanalyzerngsettings.h b/plugins/channelrx/chanalyzerng/chanalyzerngsettings.h
new file mode 100644
index 000000000..0ec677e76
--- /dev/null
+++ b/plugins/channelrx/chanalyzerng/chanalyzerngsettings.h
@@ -0,0 +1,51 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2018 Edouard Griffiths, F4EXB.                                  //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef PLUGINS_CHANNELRX_CHANALYZERNG_CHANALYZERNGSETTINGS_H_
+#define PLUGINS_CHANNELRX_CHANALYZERNG_CHANALYZERNGSETTINGS_H_
+
+#include <QByteArray>
+
+class Serializable;
+
+struct ChannelAnalyzerNGSettings
+{
+    int m_frequency;
+    bool m_downSample;
+    quint32 m_downSampleRate;
+    int m_bandwidth;
+    int m_lowCutoff;
+    int m_spanLog2;
+    bool m_ssb;
+    bool m_pll;
+    bool m_fll;
+    unsigned int m_pllPskOrder;
+    quint32 m_rgbColor;
+    QString m_title;
+    Serializable *m_channelMarker;
+    Serializable *m_spectrumGUI;
+    Serializable *m_scopeGUI;
+
+    ChannelAnalyzerNGSettings();
+    void resetToDefaults();
+    void setChannelMarker(Serializable *channelMarker) { m_channelMarker = channelMarker; }
+    QByteArray serialize() const;
+    bool deserialize(const QByteArray& data);
+};
+
+
+
+#endif /* PLUGINS_CHANNELRX_CHANALYZERNG_CHANALYZERNGSETTINGS_H_ */