You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
187 lines
6.3 KiB
187 lines
6.3 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2012 maintech GmbH, Otto-Hahn-Str. 15, 97204 Hoechberg, Germany // |
|
// written by Christian Daniel // |
|
// Copyright (C) 2015-2019, 2023 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// Copyright (C) 2026 SDRangel contributors // |
|
// // |
|
// 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 // |
|
// (at your option) any later version. // |
|
// // |
|
// 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 "dsp/fftfilterrrc.h" |
|
|
|
#include <algorithm> |
|
#include <cmath> |
|
#include <cstring> |
|
|
|
FFTFilterRRC::FFTFilterRRC(int len) : |
|
m_fftLen(len), |
|
m_fftLen2(len / 2), |
|
m_fft(nullptr), |
|
m_filter(nullptr), |
|
m_fftBuffer(nullptr), |
|
m_overlapBuffer(nullptr), |
|
m_outputBuffer(nullptr), |
|
m_inputIndex(0), |
|
m_symbolRate(0.0f), |
|
m_rolloff(0.0f) |
|
{ |
|
initFilter(); |
|
} |
|
|
|
FFTFilterRRC::~FFTFilterRRC() |
|
{ |
|
delete m_fft; |
|
delete[] m_filter; |
|
delete[] m_fftBuffer; |
|
delete[] m_overlapBuffer; |
|
delete[] m_outputBuffer; |
|
} |
|
|
|
void FFTFilterRRC::initFilter() |
|
{ |
|
m_fft = new g_fft<float>(m_fftLen); |
|
|
|
m_filter = new Complex[m_fftLen]; |
|
m_fftBuffer = new Complex[m_fftLen]; |
|
m_overlapBuffer = new Complex[m_fftLen2]; |
|
m_outputBuffer = new Complex[m_fftLen2]; |
|
|
|
// Initialize all buffers to zero |
|
std::fill(m_filter, m_filter + m_fftLen, Complex(0.0f, 0.0f)); |
|
std::fill(m_fftBuffer, m_fftBuffer + m_fftLen, Complex(0.0f, 0.0f)); |
|
std::fill(m_overlapBuffer, m_overlapBuffer + m_fftLen2, Complex(0.0f, 0.0f)); |
|
std::fill(m_outputBuffer, m_outputBuffer + m_fftLen2, Complex(0.0f, 0.0f)); |
|
|
|
m_inputIndex = 0; |
|
} |
|
|
|
void FFTFilterRRC::create(float symbolRate, float rolloff) |
|
{ |
|
m_symbolRate = symbolRate; |
|
m_rolloff = rolloff; |
|
|
|
// Clamp rolloff to valid range [0, 1] |
|
if (m_rolloff < 0.0f) { |
|
m_rolloff = 0.0f; |
|
} else if (m_rolloff > 1.0f) { |
|
m_rolloff = 1.0f; |
|
} |
|
|
|
// Create filter directly in frequency domain |
|
std::fill(m_filter, m_filter + m_fftLen, Complex(0.0f, 0.0f)); |
|
|
|
for (int i = 0; i < m_fftLen; i++) { |
|
m_filter[i] = computeRRCResponse(m_symbolRate, m_rolloff, i, m_fftLen); |
|
} |
|
|
|
// Normalize for unity gain in passband |
|
float maxMag = 0.0f; |
|
for (int i = 0; i < m_fftLen; i++) { |
|
float mag = std::abs(m_filter[i]); |
|
if (mag > maxMag) { |
|
maxMag = mag; |
|
} |
|
} |
|
|
|
if (maxMag > 0.0f) { |
|
for (int i = 0; i < m_fftLen; i++) { |
|
m_filter[i] /= maxMag; |
|
} |
|
} |
|
} |
|
|
|
FFTFilterRRC::Complex FFTFilterRRC::computeRRCResponse( |
|
float symbolRate, |
|
float rolloff, |
|
int binIndex, |
|
int fftLen) const |
|
{ |
|
// Normalize frequency to [-0.5, 0.5] |
|
// FFT bins: 0 to fftLen/2-1 are positive frequencies (0 to 0.5) |
|
// fftLen/2 to fftLen-1 are negative frequencies (-0.5 to 0) |
|
float freq = static_cast<float>(binIndex) / static_cast<float>(fftLen); |
|
|
|
// Map to [-0.5, 0.5] range |
|
if (freq > 0.5f) { |
|
freq -= 1.0f; |
|
} |
|
|
|
// Absolute frequency |
|
float absFreq = std::abs(freq); |
|
|
|
// Compute frequency boundaries |
|
// For RRC: passband is Rs/2, where Rs is symbol rate |
|
// Transition band: Rs/2 * (1-beta) to Rs/2 * (1+beta) |
|
float f1 = symbolRate * (1.0f - rolloff) / 2.0f; // Start of transition band |
|
float f2 = symbolRate * (1.0f + rolloff) / 2.0f; // End of transition band |
|
|
|
Complex response; |
|
|
|
if (absFreq <= f1) { |
|
// Passband: constant response |
|
response = Complex(1.0f, 0.0f); |
|
} else if (absFreq > f1 && absFreq <= f2) { |
|
// Transition band: raised cosine roll-off |
|
// H(f) = 0.5 * [1 + cos(pi/beta * (|f|/Rs - (1-beta)/2))] |
|
float normalizedFreq = absFreq / symbolRate; // Normalize by symbol rate |
|
float arg = (M_PI / rolloff) * (normalizedFreq - (1.0f - rolloff) / 2.0f); |
|
float amplitude = 0.5f * (1.0f + std::cos(arg)); |
|
response = Complex(amplitude, 0.0f); |
|
} else { |
|
// Stopband: zero response |
|
response = Complex(0.0f, 0.0f); |
|
} |
|
|
|
return response; |
|
} |
|
|
|
int FFTFilterRRC::process(const Complex& input, Complex** output) |
|
{ |
|
// Store input sample in first half of FFT buffer |
|
m_fftBuffer[m_inputIndex] = input; |
|
m_inputIndex++; |
|
|
|
// Process when first half is full |
|
if (m_inputIndex < m_fftLen2) { |
|
return 0; // Not enough samples yet |
|
} |
|
|
|
// Second half of FFT buffer is already zero-padded from initialization |
|
// or previous processing (overlap-add method) |
|
|
|
// Perform forward FFT |
|
m_fft->ComplexFFT(m_fftBuffer); |
|
|
|
// Apply filter in frequency domain (element-wise multiplication) |
|
for (int i = 0; i < m_fftLen; i++) { |
|
m_fftBuffer[i] *= m_filter[i]; |
|
} |
|
|
|
// Perform inverse FFT |
|
m_fft->InverseComplexFFT(m_fftBuffer); |
|
|
|
// Overlap-add: first half gets added to overlap buffer, second half becomes new overlap |
|
for (int i = 0; i < m_fftLen2; i++) { |
|
m_outputBuffer[i] = m_fftBuffer[i] + m_overlapBuffer[i]; |
|
m_overlapBuffer[i] = m_fftBuffer[i + m_fftLen2]; |
|
} |
|
|
|
// Reset input index and clear first half of FFT buffer for next block |
|
m_inputIndex = 0; |
|
std::fill(m_fftBuffer, m_fftBuffer + m_fftLen2, Complex(0.0f, 0.0f)); |
|
|
|
// Return pointer to output buffer |
|
*output = m_outputBuffer; |
|
return m_fftLen2; |
|
}
|
|
|