Merge pull request #2645 from f4exb/fix-fftrrc-2

Rework FFT RRC filter and add a FIR RRC filter

Author: f4exb

plugins/channelrx/chanalyzer/CMakeLists.txt

@@ -8,7 +8,9 @@ set(chanalyzer_SOURCES
     chanalyzersink.cpp
     chanalyzerbaseband.cpp
 	chanalyzerwebapiadapter.cpp
+    rrcfilterdialog.cpp
 	chanalyzergui.ui
+    rrcfilterdialog.ui
 )
 
 set(chanalyzer_HEADERS
@@ -19,6 +21,7 @@ set(chanalyzer_HEADERS
     chanalyzersink.h
     chanalyzerbaseband.h
 	chanalyzerwebapiadapter.h
+    rrcfilterdialog.h
 )
 
 include_directories(

plugins/channelrx/chanalyzer/chanalyzergui.cpp

@@ -30,12 +30,14 @@
 #include "gui/basicchannelsettingsdialog.h"
 #include "gui/dialpopup.h"
 #include "gui/dialogpositioner.h"
+#include "gui/crightclickenabler.h"
 #include "plugin/pluginapi.h"
 #include "util/db.h"
 #include "maincore.h"
 
 #include "ui_chanalyzergui.h"
 #include "chanalyzer.h"
+#include "rrcfilterdialog.h"
 #include "chanalyzergui.h"
 
 ChannelAnalyzerGUI* ChannelAnalyzerGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel)
@@ -559,6 +561,9 @@ ChannelAnalyzerGUI::ChannelAnalyzerGUI(PluginAPI* pluginAPI, DeviceUISet *device
     m_channelAnalyzer->setScopeVis(m_scopeVis);
 	m_channelAnalyzer->setMessageQueueToGUI(getInputMessageQueue());
 
+    m_rrcRightClickEnabler = new CRightClickEnabler(ui->rrcFilter);
+    connect(m_rrcRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(rrcSetupDialog(const QPoint &)));
+
     ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
     ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
     ui->deltaFrequency->setValueRange(false, 8, -99999999, 99999999);
@@ -735,6 +740,47 @@ void ChannelAnalyzerGUI::enterEvent(EnterEventType* event)
     ChannelGUI::enterEvent(event);
 }
 
+void ChannelAnalyzerGUI::rrcSetupDialog(const QPoint& p)
+{
+    m_rrcFilterDialog = new RRCFilterDialog();
+    m_rrcFilterDialog->move(p);
+    m_rrcFilterDialog->setRRCType(m_settings.m_rrcType);
+    m_rrcFilterDialog->setRRCSymbolSpan(m_settings.m_rrcSymbolSpan);
+    m_rrcFilterDialog->setRRCNormalization(m_settings.m_rrcNormalization);
+    m_rrcFilterDialog->setRRCFFTLog2Size(m_settings.m_rrcFFTLog2Size);
+    QObject::connect(m_rrcFilterDialog, &RRCFilterDialog::valueChanged, this, &ChannelAnalyzerGUI::rrcSetup);
+    m_rrcFilterDialog->exec();
+    m_rrcFilterDialog->deleteLater();
+    m_rrcFilterDialog = nullptr;
+}
+
+void ChannelAnalyzerGUI::rrcSetup(int iValueChanged)
+{
+    auto valueChanged = static_cast<RRCFilterDialog::ValueChanged>(iValueChanged);
+
+    switch(valueChanged)
+    {
+        case RRCFilterDialog::ValueChanged::ChangedRRCType:
+            m_settings.m_rrcType = m_rrcFilterDialog->getRRCType();
+            applySettings(QStringList({"rrcType"}));
+            break;
+        case RRCFilterDialog::ValueChanged::ChangedRRCSymbolSpan:
+            m_settings.m_rrcSymbolSpan = m_rrcFilterDialog->getRRCSymbolSpan();
+            applySettings(QStringList({"rrcSymbolSpan"}));
+            break;
+        case RRCFilterDialog::ValueChanged::ChangedRRCNormalization:
+            m_settings.m_rrcNormalization = m_rrcFilterDialog->getRRCNormalization();
+            applySettings(QStringList({"rrcNormalization"}));
+            break;
+        case RRCFilterDialog::ValueChanged::ChangedRRCFFTLog2Size:
+            m_settings.m_rrcFFTLog2Size = m_rrcFilterDialog->getRRCFFTLog2Size();
+            applySettings(QStringList({"rrcFFTLog2Size"}));
+            break;
+        default:
+            break;
+    }
+}
+
 void ChannelAnalyzerGUI::makeUIConnections()
 {
     QObject::connect(ui->deltaFrequency, &ValueDialZ::changed, this, &ChannelAnalyzerGUI::on_deltaFrequency_changed);

plugins/channelrx/chanalyzer/chanalyzergui.h

@@ -35,6 +35,8 @@ class BasebandSampleSink;
 class ChannelAnalyzer;
 class SpectrumVis;
 class ScopeVis;
+class RRCFilterDialog;
+class CRightClickEnabler;
 
 namespace Ui {
 	class ChannelAnalyzerGUI;
@@ -83,6 +85,8 @@ public slots:
 	SpectrumVis* m_spectrumVis;
 	ScopeVis* m_scopeVis;
 	MessageQueue m_inputMessageQueue;
+	RRCFilterDialog* m_rrcFilterDialog;
+	CRightClickEnabler* m_rrcRightClickEnabler;
 
 	explicit ChannelAnalyzerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* parent = nullptr);
 	virtual ~ChannelAnalyzerGUI();
@@ -123,6 +127,8 @@ private slots:
 	void on_ssb_toggled(bool checked);
 	void onWidgetRolled(QWidget* widget, bool rollDown);
     void onMenuDialogCalled(const QPoint& p);
+	void rrcSetupDialog(const QPoint& p);
+	void rrcSetup(int valueChanged);
     void handleInputMessages();
 	void tick();
 };

plugins/channelrx/chanalyzer/chanalyzergui.ui

@@ -418,7 +418,7 @@
       <item>
        <widget class="ButtonSwitch" name="rrcFilter">
         <property name="toolTip">
-         <string>Toggle RRC filter</string>
+         <string>Toggle RRC filter - Right click for options</string>
         </property>
         <property name="text">
          <string/>

plugins/channelrx/chanalyzer/chanalyzersettings.cpp

@@ -46,6 +46,10 @@ void ChannelAnalyzerSettings::resetToDefaults()
     m_costasLoop = false;
     m_rrc = false;
     m_rrcRolloff = 35; // 0.35
+    m_rrcType = RRCFIR;
+    m_rrcSymbolSpan = 8;
+    m_rrcNormalization = RRCNormGain;
+    m_rrcFFTLog2Size = 9; // 512
     m_pllPskOrder = 1;
     m_pllBandwidth = 0.002f;
     m_pllDampingFactor = 0.5f;
@@ -110,6 +114,10 @@ QByteArray ChannelAnalyzerSettings::serialize() const
     s.writeS32(29, m_workspaceIndex);
     s.writeBlob(30, m_geometryBytes);
     s.writeBool(31, m_hidden);
+    s.writeS32(32, m_rrcType);
+    s.writeS32(33, m_rrcSymbolSpan);
+    s.writeS32(34, m_rrcNormalization);
+    s.writeS32(35, m_rrcFFTLog2Size);
 
     return s.final();
 }
@@ -187,6 +195,12 @@ bool ChannelAnalyzerSettings::deserialize(const QByteArray& data)
         d.readS32(29, &m_workspaceIndex, 0);
         d.readBlob(30, &m_geometryBytes);
         d.readBool(31, &m_hidden, false);
+        d.readS32(32, &tmp, 0);
+        m_rrcType = (RRCType) tmp;
+        d.readS32(33, &m_rrcSymbolSpan, 8);
+        d.readS32(34, &tmp, 2);
+        m_rrcNormalization = (RRCNormalization) tmp;
+        d.readS32(35, &m_rrcFFTLog2Size, 9);
 
         return true;
     }
@@ -235,6 +249,18 @@ void ChannelAnalyzerSettings::applySettings(const QStringList& settingsKeys, con
     if (settingsKeys.contains("rrcRolloff")) {
         m_rrcRolloff = settings.m_rrcRolloff;
     }
+    if (settingsKeys.contains("rrcType")) {
+        m_rrcType = settings.m_rrcType;
+    }
+    if (settingsKeys.contains("rrcSymbolSpan")) {
+        m_rrcSymbolSpan = settings.m_rrcSymbolSpan;
+    }
+    if (settingsKeys.contains("rrcNormalization")) {
+        m_rrcNormalization = settings.m_rrcNormalization;
+    }
+    if (settingsKeys.contains("rrcFFTLog2Size")) {
+        m_rrcFFTLog2Size = settings.m_rrcFFTLog2Size;
+    }
     if (settingsKeys.contains("pllPskOrder")) {
         m_pllPskOrder = settings.m_pllPskOrder;
     }
@@ -322,6 +348,18 @@ QString ChannelAnalyzerSettings::getDebugString(const QStringList& settingsKeys,
     if (settingsKeys.contains("rrcRolloff") || force) {
         ostr << " m_rrcRolloff: " << m_rrcRolloff;
     }
+    if (settingsKeys.contains("rrcType") || force) {
+        ostr << " m_rrcType: " << m_rrcType;
+    }
+    if (settingsKeys.contains("rrcSymbolSpan") || force) {
+        ostr << " m_rrcSymbolSpan: " << m_rrcSymbolSpan;
+    }
+    if (settingsKeys.contains("rrcNormalization") || force) {
+        ostr << " m_rrcNormalization: " << m_rrcNormalization;
+    }
+    if (settingsKeys.contains("rrcFFTLog2Size") || force) {
+        ostr << " m_rrcFFTLog2Size: " << m_rrcFFTLog2Size;
+    }
     if (settingsKeys.contains("pllPskOrder") || force) {
         ostr << " m_pllPskOrder: " << m_pllPskOrder;
     }

plugins/channelrx/chanalyzer/chanalyzersettings.h

@@ -34,6 +34,19 @@ struct ChannelAnalyzerSettings
         InputAutoCorr
     };
 
+    enum RRCType
+    {
+        RRCFIR,
+        RRCFFT
+    };
+
+    enum RRCNormalization
+    {
+        RRCNormEnergy,
+        RRCNormAmpltude,
+        RRCNormGain
+    };
+
     int m_inputFrequencyOffset;
     bool m_rationalDownSample;
     quint32 m_rationalDownSamplerRate;
@@ -46,6 +59,10 @@ struct ChannelAnalyzerSettings
     bool m_costasLoop;
     bool m_rrc;
     quint32 m_rrcRolloff; //!< in 100ths
+    RRCType m_rrcType;
+    int m_rrcSymbolSpan;
+    RRCNormalization m_rrcNormalization;
+    int m_rrcFFTLog2Size;
     unsigned int m_pllPskOrder;
     float m_pllBandwidth;
     float m_pllDampingFactor;

plugins/channelrx/chanalyzer/chanalyzersink.cpp

@@ -28,6 +28,52 @@
 const unsigned int ChannelAnalyzerSink::m_ssbFftLen = 1024;
 const unsigned int ChannelAnalyzerSink::m_corrFFTLen = 4*m_ssbFftLen;
 
+ChannelAnalyzerSink::RRCHelper::RRCHelper(int flen) :
+    m_useFFT(false),
+    m_filterFIR(new FIRFilterRRC()),
+    m_filterFFT(new FFTFilterRRC(m_ssbFftLen)),
+    m_buffer(new std::complex<float>[flen/2]),
+    m_bufferPos(0),
+    flen2(flen/2)
+{
+}
+
+ChannelAnalyzerSink::RRCHelper::~RRCHelper()
+{
+    delete m_filterFIR;
+    delete[] m_buffer;
+}
+
+void ChannelAnalyzerSink::RRCHelper::setUseFFT(bool useFFT)
+{
+    m_useFFT = useFFT;
+    m_bufferPos = 0;
+}
+
+void ChannelAnalyzerSink::RRCHelper::create(float symbolRate, float rolloff, unsigned int samplesPerSymbol, FIRFilterRRC::Normalization normalization)
+{
+    m_filterFIR->create(symbolRate, rolloff, samplesPerSymbol, normalization);
+    m_filterFFT->create(symbolRate, rolloff);
+}
+
+int ChannelAnalyzerSink::RRCHelper::runFilt(const std::complex<float> & in, std::complex<float> **out)
+{
+    if (m_useFFT) {
+        return m_filterFFT->process(in, out);
+    } else {
+        m_buffer[m_bufferPos++] = m_filterFIR->filter(in);
+    }
+
+    if (m_bufferPos < flen2) {
+        *out = nullptr;
+        return 0;
+    }
+
+    m_bufferPos = 0;
+    *out = m_buffer;
+    return flen2;
+}
+
 ChannelAnalyzerSink::ChannelAnalyzerSink() :
     m_channelSampleRate(48000),
     m_channelFrequencyOffset(0),
@@ -39,7 +85,8 @@ ChannelAnalyzerSink::ChannelAnalyzerSink() :
 	m_magsq = 0;
 	SSBFilter = new fftfilt(m_settings.m_lowCutoff / m_channelSampleRate, m_settings.m_bandwidth / m_channelSampleRate, m_ssbFftLen);
 	DSBFilter = new fftfilt(m_settings.m_bandwidth / m_channelSampleRate, 2*m_ssbFftLen);
-	RRCFilter = new fftfilt(m_settings.m_bandwidth / m_channelSampleRate, 2*m_ssbFftLen);
+	m_rrcHelper = new RRCHelper(2*m_ssbFftLen);
+    // m_rrcHelper->setUseFFT(true);
 	m_corr = new fftcorr(2*m_corrFFTLen); // 8k for 4k effective samples
 	m_pll.computeCoefficients(m_settings.m_pllBandwidth, m_settings.m_pllDampingFactor, m_settings.m_pllLoopGain);
         m_costasLoop.computeCoefficients(m_settings.m_pllBandwidth);
@@ -52,7 +99,7 @@ ChannelAnalyzerSink::~ChannelAnalyzerSink()
 {
     delete SSBFilter;
     delete DSBFilter;
-    delete RRCFilter;
+    delete m_rrcHelper;
     delete m_corr;
 }
 
@@ -126,7 +173,7 @@ void ChannelAnalyzerSink::processOneSample(Complex& c, fftfilt::cmplx *sideband)
     else
     {
         if (m_settings.m_rrc) {
-            n_out = RRCFilter->runFilt(c, &sideband);
+            n_out = m_rrcHelper->runFilt(c, &sideband);
         } else {
             n_out = DSBFilter->runDSB(c, &sideband);
         }
@@ -240,7 +287,7 @@ void ChannelAnalyzerSink::setFilters(int sampleRate, float bandwidth, float lowC
 
     SSBFilter->create_filter(lowCutoff / sampleRate, bandwidth / sampleRate);
     DSBFilter->create_dsb_filter(bandwidth / sampleRate);
-    RRCFilter->create_rrc_filter(bandwidth / sampleRate, m_settings.m_rrcRolloff / 100.0);
+    m_rrcHelper->create(bandwidth / sampleRate, m_settings.m_rrcRolloff / 100.0, m_settings.m_rrcSymbolSpan, (FIRFilterRRC::Normalization) m_settings.m_rrcNormalization);
 }
 
 void ChannelAnalyzerSink::applySettings(const ChannelAnalyzerSettings& settings, const QStringList& settingsKeys, bool force)
@@ -314,6 +361,29 @@ void ChannelAnalyzerSink::applySettings(const ChannelAnalyzerSettings& settings,
         }
     }
 
+    if (settings.m_rrcType != m_settings.m_rrcType || force)
+    {
+        m_rrcHelper->setUseFFT(settings.m_rrcType == ChannelAnalyzerSettings::RRCFFT);
+    }
+
+    if (settings.m_rrcSymbolSpan != m_settings.m_rrcSymbolSpan || force)
+    {
+        m_rrcHelper->create(m_settings.m_bandwidth / (float) m_sinkSampleRate, m_settings.m_rrcRolloff / 100.0, settings.m_rrcSymbolSpan, (FIRFilterRRC::Normalization) m_settings.m_rrcNormalization);
+    }
+
+    if (settings.m_rrcNormalization != m_settings.m_rrcNormalization || force)
+    {
+        m_rrcHelper->create(m_settings.m_bandwidth / (float) m_sinkSampleRate, m_settings.m_rrcRolloff / 100.0, m_settings.m_rrcSymbolSpan, (FIRFilterRRC::Normalization) settings.m_rrcNormalization);
+    }
+
+    if (settings.m_rrcFFTLog2Size != m_settings.m_rrcFFTLog2Size || force)
+    {
+        delete m_rrcHelper;
+        m_rrcHelper = new RRCHelper(1 << settings.m_rrcFFTLog2Size);
+        m_rrcHelper->create(settings.m_bandwidth / (float) m_sinkSampleRate, settings.m_rrcRolloff / 100.0, settings.m_rrcSymbolSpan, (FIRFilterRRC::Normalization) settings.m_rrcNormalization);
+        m_rrcHelper->setUseFFT(settings.m_rrcType == ChannelAnalyzerSettings::RRCFFT);
+    }
+
     if (force) {
         m_settings = settings;
     } else {
@@ -383,5 +453,5 @@ void ChannelAnalyzerSink::applySampleRate()
     m_pll.setSampleRate(sampleRate);
     m_fll.setSampleRate(sampleRate);
     m_costasLoop.setSampleRate(sampleRate);
-    RRCFilter->create_rrc_filter(m_settings.m_bandwidth / (float) sampleRate, m_settings.m_rrcRolloff / 100.0);
+    m_rrcHelper->create(m_settings.m_bandwidth / (float) sampleRate, m_settings.m_rrcRolloff / 100.0, m_settings.m_rrcSymbolSpan, (FIRFilterRRC::Normalization) m_settings.m_rrcNormalization);
 }

plugins/channelrx/chanalyzer/chanalyzersink.h

@@ -25,6 +25,8 @@
 #include "dsp/nco.h"
 #include "dsp/fftcorr.h"
 #include "dsp/fftfilt.h"
+#include "dsp/firfilterrrc.h"
+#include "dsp/fftfilterrrc.h"
 #include "dsp/phaselockcomplex.h"
 #include "dsp/freqlockcomplex.h"
 #include "dsp/costasloop.h"
@@ -57,6 +59,22 @@ class ChannelAnalyzerSink : public ChannelSampleSink {
     static const unsigned int m_ssbFftLen;
 
 private:
+    class RRCHelper {
+    public:
+        RRCHelper(int flen);
+        ~RRCHelper();
+        void setUseFFT(bool useFFT);
+        void create(float symbolRate, float rolloff, unsigned int samplesPerSymbol, FIRFilterRRC::Normalization normalization);
+        int runFilt(const std::complex<float> & in, std::complex<float> **out);
+    private:
+        bool m_useFFT;
+        FIRFilterRRC* m_filterFIR;
+        FFTFilterRRC* m_filterFFT;
+        std::complex<float>* m_buffer;
+        int m_bufferPos;
+        int flen2;
+    };
+
     int m_channelSampleRate;
 	int m_channelFrequencyOffset;
     int m_sinkSampleRate;
@@ -76,7 +94,7 @@ class ChannelAnalyzerSink : public ChannelSampleSink {
 
 	fftfilt* SSBFilter;
 	fftfilt* DSBFilter;
-	fftfilt* RRCFilter;
+	RRCHelper* m_rrcHelper;
 	fftcorr* m_corr;
 
 	SampleVector m_sampleBuffer;