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.
1019 lines
38 KiB
1019 lines
38 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Some code by AI // |
|
// // |
|
// 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 <algorithm> |
|
#include <cmath> |
|
#include <cstdio> |
|
#include <cstdlib> |
|
#include <numeric> |
|
|
|
#include "dabprofile.h" |
|
#include "dabofdm.h" |
|
|
|
namespace modemdab |
|
{ |
|
|
|
namespace |
|
{ |
|
|
|
constexpr double Pi = 3.14159265358979323846; |
|
constexpr int Margin = ModeI::FFTSize; // Samples kept either side of a frame |
|
constexpr int NullBlock = 64; // Power averaging block for null detection |
|
constexpr int NullWindowBlocks = 40; // 2560 samples, inside the 2656 sample null |
|
constexpr int TimingMargin = 24; // Samples of guard kept before the first path |
|
constexpr int MaxTrackingStep = 32; // Larger timing steps need confirming |
|
constexpr float MinAcquisitionQuality = 3.0f; // Integer offset correlation peak to mean |
|
constexpr float MinImpulseQualityDB = 9.0f; // Impulse response peak to mean, to lock |
|
constexpr float MinTrackingQualityDB = 6.0f; // and to keep lock |
|
constexpr int MaxBadFrames = 8; |
|
// A frame whose impulse response quality is this far below the locked average has lost the |
|
// signal's timing: samples were lost before the input, so the frames are not where expected. |
|
// A few such frames in a row are enough to search again. |
|
constexpr float CollapseDB = 12.0f; |
|
constexpr int MaxCollapsedFrames = 3; |
|
// Band filter: overlap-save with a 4096 point FFT and a 511 tap Kaiser windowed lowpass |
|
constexpr int FilterFFTSize = 4096; |
|
constexpr int FilterTaps = 511; |
|
constexpr int FilterStep = FilterFFTSize - FilterTaps + 1; |
|
constexpr double FilterCutoffHz = 785000.0; |
|
|
|
bool debugEnabled() |
|
{ |
|
static const bool enabled = std::getenv("MODEMDAB_DEBUG") != nullptr; |
|
return enabled; |
|
} |
|
|
|
inline int binForCarrier(int k) |
|
{ |
|
return (k + ModeI::FFTSize) % ModeI::FFTSize; |
|
} |
|
|
|
// Index of carrier k (-768..768, k != 0) among the 1536 active carriers |
|
inline int carrierIndex(int k) |
|
{ |
|
return k < 0 ? k + 768 : k + 767; |
|
} |
|
|
|
} // anonymous namespace |
|
|
|
DABFrontEnd::DABFrontEnd() : |
|
m_state(State::Searching), |
|
m_searchRange(35), |
|
m_bufferStart(0), |
|
m_frameStart(0), |
|
m_frameStartFraction(0.0), |
|
m_frequency(0.0), |
|
m_clockErrorPPM(0.0f), |
|
m_driftPerFrame(0.0f), |
|
m_haveTiming(false), |
|
m_lastFineTiming(0.0), |
|
m_integerOffsetVotes(0), |
|
m_lastIntegerOffset(0), |
|
m_badFrames(0), |
|
m_pendingShift(0), |
|
m_acquisitionAttempts(0), |
|
m_locks(0), |
|
m_fft(ModeI::FFTSize, false), |
|
m_ifft(ModeI::FFTSize, true), |
|
m_bandFilter(true), |
|
m_dcRemoval(true), |
|
m_impulseAverage(0.0f), |
|
m_haveImpulseAverage(false), |
|
m_lastNullDepth(0.0f), |
|
m_haveLastNullDepth(false), |
|
m_dc(0.0, 0.0), |
|
m_detection(Detection::Differential), |
|
m_exportCarriers(false), |
|
m_filterFFT(FilterFFTSize, false), |
|
m_filterIFFT(FilterFFTSize, true), |
|
m_haveCarrierNoise(false), |
|
m_noiseFrames(0), |
|
m_haveCarrierPower(false) |
|
{ |
|
// Kaiser windowed sinc (beta 7.86 for about 80 dB of stop band attenuation) |
|
std::vector<std::complex<float>> taps(FilterFFTSize, 0.0f); |
|
const double fc = FilterCutoffHz / ModeI::SampleRate; |
|
const double beta = 7.86; |
|
auto bessel0 = [](double x) { |
|
double sum = 1.0; |
|
double term = 1.0; |
|
for (int k = 1; k < 30; k++) |
|
{ |
|
term *= (x / (2.0 * k)) * (x / (2.0 * k)); |
|
sum += term; |
|
} |
|
return sum; |
|
}; |
|
const double centre = (FilterTaps - 1) / 2.0; |
|
for (int n = 0; n < FilterTaps; n++) |
|
{ |
|
const double t = n - centre; |
|
const double sinc = t == 0.0 ? 2.0 * fc : std::sin(2.0 * Pi * fc * t) / (Pi * t); |
|
const double r = t / centre; |
|
const double window = bessel0(beta * std::sqrt(std::max(0.0, 1.0 - r * r))) / bessel0(beta); |
|
taps[n] = static_cast<float>(sinc * window / FilterFFTSize); |
|
} |
|
m_filterResponse.resize(FilterFFTSize); |
|
m_filterFFT.transform(taps.data(), m_filterResponse.data()); |
|
m_filterInput.assign(FilterTaps - 1, 0.0f); |
|
m_filterWork.resize(FilterFFTSize); |
|
|
|
m_fftIn.resize(ModeI::FFTSize); |
|
m_symbols.resize(ModeI::SymbolsPerFrame, std::vector<std::complex<float>>(ModeI::FFTSize)); |
|
m_differential.resize((ModeI::SymbolsPerFrame - 1) * ModeI::Carriers); |
|
m_softCarrier.resize(ModeI::Carriers); |
|
for (int i = 0; i < ModeI::Carriers; i++) { |
|
m_softCarrier[i] = carrierIndex(DABTables::frequencyInterleaving()[i]); |
|
} |
|
m_carrierNoise.resize(ModeI::Carriers, 1.0f); |
|
m_lastNullPower.resize(ModeI::Carriers, 0.0f); |
|
m_carrierPower.resize(ModeI::Carriers, 0.0f); |
|
m_frame.ficSoft.resize(ModeI::FICSymbols * ModeI::BitsPerSymbol); |
|
m_frame.mscSoft.resize(ModeI::MSCSymbols * ModeI::BitsPerSymbol); |
|
m_frame.nullSpectrum.resize(ModeI::FFTSize); |
|
} |
|
|
|
void DABFrontEnd::setSearchRange(int rangeHz) |
|
{ |
|
m_searchRange = std::max(1, std::min(rangeHz / 1000, 300)); |
|
} |
|
|
|
void DABFrontEnd::setBandFilter(bool enabled) |
|
{ |
|
m_bandFilter = enabled; |
|
} |
|
|
|
void DABFrontEnd::filter(const std::complex<float> *samples, std::size_t count) |
|
{ |
|
DABProfileScope profile(DABProfile::BandFilter); |
|
m_filterInput.insert(m_filterInput.end(), samples, samples + count); |
|
std::vector<std::complex<float>> spectrum(FilterFFTSize); |
|
std::size_t position = 0; |
|
|
|
// Each block of the FFT size gives FilterStep outputs free of circular wrap |
|
while (m_filterInput.size() - position >= static_cast<std::size_t>(FilterFFTSize)) |
|
{ |
|
m_filterFFT.transform(&m_filterInput[position], spectrum.data()); |
|
for (int i = 0; i < FilterFFTSize; i++) { |
|
spectrum[i] *= m_filterResponse[i]; |
|
} |
|
m_filterIFFT.transform(spectrum.data(), m_filterWork.data()); |
|
m_buffer.insert(m_buffer.end(), m_filterWork.begin() + (FilterTaps - 1), m_filterWork.end()); |
|
position += FilterStep; |
|
} |
|
m_filterInput.erase(m_filterInput.begin(), m_filterInput.begin() + position); |
|
} |
|
|
|
void DABFrontEnd::reset() |
|
{ |
|
m_bufferStart += static_cast<int64_t>(m_buffer.size()); |
|
m_buffer.clear(); |
|
m_acquisitionAttempts = 0; |
|
m_locks = 0; |
|
m_frequency = 0.0; |
|
m_clockErrorPPM = 0.0f; |
|
m_driftPerFrame = 0.0f; |
|
reacquire(); |
|
} |
|
|
|
void DABFrontEnd::reacquire() |
|
{ |
|
m_state = State::Searching; |
|
m_haveTiming = false; |
|
m_haveCarrierNoise = false; |
|
m_noiseFrames = 0; |
|
m_haveCarrierPower = false; |
|
m_haveLastNullDepth = false; |
|
m_haveImpulseAverage = false; |
|
std::fill(m_lastNullPower.begin(), m_lastNullPower.end(), 0.0f); |
|
m_frameStartFraction = 0.0; |
|
m_integerOffsetVotes = 0; |
|
m_badFrames = 0; |
|
m_pendingShift = 0; |
|
} |
|
|
|
void DABFrontEnd::process(const std::complex<float> *samples, std::size_t count) |
|
{ |
|
if (m_dcRemoval && (count > 0)) |
|
{ |
|
// The mean of each block, smoothed with a time constant of about 0.1 s; the |
|
// ensemble's own contribution averages out far below the carriers |
|
std::complex<double> sum = 0.0; |
|
for (std::size_t i = 0; i < count; i++) { |
|
sum += std::complex<double>(samples[i]); |
|
} |
|
const double alpha = std::min(1.0, static_cast<double>(count) / (0.1 * ModeI::SampleRate)); |
|
m_dc += alpha * (sum / static_cast<double>(count) - m_dc); |
|
const std::complex<float> dc(m_dc); |
|
m_dcRemoved.resize(count); |
|
for (std::size_t i = 0; i < count; i++) { |
|
m_dcRemoved[i] = samples[i] - dc; |
|
} |
|
samples = m_dcRemoved.data(); |
|
} |
|
|
|
if (m_bandFilter) { |
|
filter(samples, count); |
|
} else { |
|
m_buffer.insert(m_buffer.end(), samples, samples + count); |
|
} |
|
|
|
while (true) |
|
{ |
|
const int64_t bufferEnd = m_bufferStart + static_cast<int64_t>(m_buffer.size()); |
|
|
|
if (m_state == State::Searching) |
|
{ |
|
const int64_t needed = 2 * ModeI::FrameSize + 3 * ModeI::NullSize + 2 * Margin; |
|
if (static_cast<int64_t>(m_buffer.size()) < needed) { |
|
break; |
|
} |
|
m_acquisitionAttempts++; |
|
if (!acquire()) { |
|
discard(m_bufferStart + ModeI::FrameSize / 2, true); |
|
} |
|
} |
|
else |
|
{ |
|
if (m_frameStart - Margin < m_bufferStart) |
|
{ |
|
// Timing moved before the buffered input: search again further on, as the |
|
// same input would give the same timing |
|
if (debugEnabled()) { |
|
std::fprintf(stderr, "track: timing moved before the input, reacquire\n"); |
|
} |
|
reacquire(); |
|
discard(m_bufferStart + ModeI::FrameSize / 2, true); |
|
continue; |
|
} |
|
if (m_frameStart + ModeI::FrameSize + Margin > bufferEnd) { |
|
break; |
|
} |
|
processFrame(); |
|
discard(m_frameStart - 2 * Margin); |
|
} |
|
} |
|
} |
|
|
|
void DABFrontEnd::discard(int64_t upTo, bool now) |
|
{ |
|
int64_t count = upTo - m_bufferStart; |
|
|
|
if (count <= 0) { |
|
return; |
|
} |
|
count = std::min(count, static_cast<int64_t>(m_buffer.size())); |
|
// Otherwise erase in large steps only, to limit copying |
|
if (!now && (count < ModeI::FrameSize) && (count < static_cast<int64_t>(m_buffer.size()))) { |
|
return; |
|
} |
|
m_buffer.erase(m_buffer.begin(), m_buffer.begin() + count); |
|
m_bufferStart += count; |
|
} |
|
|
|
void DABFrontEnd::mix(int64_t start, int length, double frequency, std::vector<std::complex<float>>& out) const |
|
{ |
|
DABProfileScope profile(DABProfile::Mixing); |
|
const double increment = -2.0 * Pi * frequency / ModeI::SampleRate; |
|
const std::complex<float> *in = &m_buffer[start - m_bufferStart]; |
|
|
|
// The rotation within a block of 1024 samples is tabulated, and the block's starting |
|
// rotation computed exactly, so rounding errors do not accumulate |
|
constexpr int Block = 1024; |
|
float tableRe[Block]; |
|
float tableIm[Block]; |
|
for (int j = 0; j < Block; j++) |
|
{ |
|
tableRe[j] = static_cast<float>(std::cos(increment * j)); |
|
tableIm[j] = static_cast<float>(std::sin(increment * j)); |
|
} |
|
|
|
out.resize(length); |
|
const float *src = reinterpret_cast<const float *>(in); |
|
float *dst = reinterpret_cast<float *>(out.data()); |
|
|
|
for (int i = 0; i < length; i += Block) |
|
{ |
|
const float baseRe = static_cast<float>(std::cos(increment * i)); |
|
const float baseIm = static_cast<float>(std::sin(increment * i)); |
|
const int count = std::min(Block, length - i); |
|
const float *x = &src[2 * i]; |
|
float *y = &dst[2 * i]; |
|
|
|
for (int j = 0; j < count; j++) |
|
{ |
|
const float rotationRe = baseRe * tableRe[j] - baseIm * tableIm[j]; |
|
const float rotationIm = baseRe * tableIm[j] + baseIm * tableRe[j]; |
|
const float re = x[2 * j]; |
|
const float im = x[2 * j + 1]; |
|
y[2 * j] = re * rotationRe - im * rotationIm; |
|
y[2 * j + 1] = re * rotationIm + im * rotationRe; |
|
} |
|
} |
|
} |
|
|
|
std::complex<float> DABFrontEnd::cyclicPrefixCorrelation(const std::complex<float> *frame, int windowOffset) const |
|
{ |
|
DABProfileScope profile(DABProfile::Mixing); |
|
// The guard interval repeats the end of each symbol, 2048 samples later |
|
std::complex<double> sum = 0.0; |
|
|
|
for (int l = 1; l <= ModeI::SymbolsPerFrame; l++) |
|
{ |
|
const int start = ModeI::NullSize + (l - 1) * ModeI::SymbolSize + windowOffset; |
|
for (int n = 16; n < ModeI::GuardSize - 16; n++) { |
|
sum += std::complex<double>(frame[start + n] * std::conj(frame[start + n + ModeI::FFTSize])); |
|
} |
|
} |
|
return std::complex<float>(static_cast<float>(sum.real()), static_cast<float>(sum.imag())); |
|
} |
|
|
|
void DABFrontEnd::symbolFFT(const std::complex<float> *window, std::vector<std::complex<float>>& out) |
|
{ |
|
DABProfileScope profile(DABProfile::SymbolFFT); |
|
out.resize(ModeI::FFTSize); |
|
m_fft.transform(window, out.data()); |
|
} |
|
|
|
int DABFrontEnd::integerFrequencyOffset(const std::vector<std::complex<float>>& prs, int range, float& quality) const |
|
{ |
|
// Correlate the phase differences of adjacent carriers with those of the phase reference. |
|
// A timing error rotates every difference equally, so only the magnitude is compared. |
|
const auto& reference = DABTables::phaseReference(); |
|
std::vector<std::complex<float>> normalized(ModeI::FFTSize); |
|
|
|
for (int i = 0; i < ModeI::FFTSize; i++) |
|
{ |
|
float magnitude = std::abs(prs[i]); |
|
normalized[i] = magnitude > 0.0f ? prs[i] / magnitude : 0.0f; |
|
} |
|
|
|
std::vector<float> correlation(2 * range + 1); |
|
int best = 0; |
|
|
|
for (int s = -range; s <= range; s++) |
|
{ |
|
std::complex<float> sum = 0.0f; |
|
|
|
for (int k = -ModeI::Carriers / 2 + 1; k <= ModeI::Carriers / 2; k++) |
|
{ |
|
if ((k == 0) || (k == 1)) { |
|
continue; |
|
} |
|
const std::complex<float> rx = normalized[binForCarrier(k + s)] * std::conj(normalized[binForCarrier(k - 1 + s)]); |
|
const std::complex<float> ref = reference[k + 768] * std::conj(reference[k - 1 + 768]); |
|
sum += rx * std::conj(ref); |
|
} |
|
correlation[s + range] = std::abs(sum); |
|
if (correlation[s + range] > correlation[best]) { |
|
best = s + range; |
|
} |
|
} |
|
|
|
float others = 0.0f; |
|
for (int i = 0; i < 2 * range + 1; i++) |
|
{ |
|
if (i != best) { |
|
others += correlation[i]; |
|
} |
|
} |
|
others /= std::max(1, 2 * range); |
|
quality = others > 0.0f ? correlation[best] / others : 0.0f; |
|
return best - range; |
|
} |
|
|
|
int DABFrontEnd::timingFromImpulseResponse(const std::vector<std::complex<float>>& prs, float& qualityDB, double& fineTiming) |
|
{ |
|
const auto& reference = DABTables::phaseReference(); |
|
std::vector<std::complex<float>> h(ModeI::FFTSize, 0.0f); |
|
std::vector<std::complex<float>> impulse(ModeI::FFTSize); |
|
std::complex<float> slope = 0.0f; |
|
std::complex<float> previous = 0.0f; |
|
|
|
for (int k = -ModeI::Carriers / 2; k <= ModeI::Carriers / 2; k++) |
|
{ |
|
if (k == 0) |
|
{ |
|
previous = 0.0f; |
|
continue; |
|
} |
|
const std::complex<float> v = prs[binForCarrier(k)] * std::conj(reference[k + 768]); |
|
h[binForCarrier(k)] = v; |
|
slope += v * std::conj(previous); |
|
previous = v; |
|
} |
|
|
|
// Mean delay, used to track the sample clock |
|
fineTiming = -std::arg(slope) * ModeI::FFTSize / (2.0 * Pi); |
|
|
|
m_ifft.transform(h.data(), impulse.data()); |
|
|
|
std::vector<float> power(2 * ModeI::FFTSize + 1); |
|
float peak = 0.0f; |
|
double total = 0.0; |
|
|
|
for (int n = 0; n < ModeI::FFTSize; n++) |
|
{ |
|
const float p = std::norm(impulse[n]); |
|
power[n] = p; |
|
peak = std::max(peak, p); |
|
total += p; |
|
} |
|
const double mean = total / ModeI::FFTSize; |
|
qualityDB = (mean > 0.0) ? static_cast<float>(10.0 * std::log10(peak / mean)) : 0.0f; |
|
|
|
// Energy inside the guard interval for each window position: paths at n in [d, d + guard] |
|
// are received without inter-symbol interference when the window moves by d. |
|
std::vector<double> prefix(2 * ModeI::FFTSize + 1, 0.0); |
|
for (int i = 0; i < 2 * ModeI::FFTSize; i++) { |
|
prefix[i + 1] = prefix[i] + power[i % ModeI::FFTSize]; |
|
} |
|
|
|
const int length = ModeI::GuardSize + 1; |
|
std::vector<double> energy(ModeI::FFTSize); |
|
int bestIndex = 0; |
|
|
|
// Index i stands for a shift of i - FFTSize / 2 |
|
for (int i = 0; i < ModeI::FFTSize; i++) |
|
{ |
|
const int shift = i - ModeI::FFTSize / 2; |
|
const int start = (shift + ModeI::FFTSize) % ModeI::FFTSize; |
|
energy[i] = prefix[start + length] - prefix[start]; |
|
if (energy[i] > energy[bestIndex]) { |
|
bestIndex = i; |
|
} |
|
} |
|
|
|
// The window can move anywhere on the plateau around the best position without losing |
|
// energy: put it as late as possible, less a margin, so pre-echoes are also covered. |
|
const double threshold = 0.98 * energy[bestIndex]; |
|
int last = bestIndex; |
|
int first = bestIndex; |
|
|
|
while ((last + 1 < ModeI::FFTSize) && (energy[last + 1] >= threshold)) { |
|
last++; |
|
} |
|
while ((first > 0) && (energy[first - 1] >= threshold)) { |
|
first--; |
|
} |
|
|
|
const int margin = std::min(TimingMargin, (last - first) / 2); |
|
return (last - margin) - ModeI::FFTSize / 2; |
|
} |
|
|
|
bool DABFrontEnd::acquire() |
|
{ |
|
DABProfileScope profile(DABProfile::Acquisition); |
|
// Find the null symbol: the lowest power window in a frame's worth of input |
|
const int searchStart = Margin; |
|
const int searchBlocks = (ModeI::FrameSize + ModeI::NullSize) / NullBlock; |
|
const int totalBlocks = searchBlocks + NullWindowBlocks; |
|
std::vector<double> blockPower(totalBlocks); |
|
|
|
for (int b = 0; b < totalBlocks; b++) |
|
{ |
|
double sum = 0.0; |
|
const std::complex<float> *p = &m_buffer[searchStart + b * NullBlock]; |
|
for (int i = 0; i < NullBlock; i++) { |
|
sum += std::norm(p[i]); |
|
} |
|
blockPower[b] = sum; |
|
} |
|
|
|
double window = 0.0; |
|
for (int b = 0; b < NullWindowBlocks; b++) { |
|
window += blockPower[b]; |
|
} |
|
|
|
double minimum = window; |
|
int minimumBlock = 0; |
|
|
|
for (int b = 1; b < searchBlocks; b++) |
|
{ |
|
window += blockPower[b + NullWindowBlocks - 1] - blockPower[b - 1]; |
|
if (window < minimum) |
|
{ |
|
minimum = window; |
|
minimumBlock = b; |
|
} |
|
} |
|
|
|
const double mean = std::accumulate(blockPower.begin(), blockPower.begin() + ModeI::FrameSize / NullBlock, 0.0) |
|
/ (ModeI::FrameSize / NullBlock); |
|
|
|
if (debugEnabled()) { |
|
std::fprintf(stderr, "acquire: null ratio %.3f at block %d\n", mean > 0.0 ? minimum / (NullWindowBlocks * mean) : 0.0, minimumBlock); |
|
} |
|
if ((mean <= 0.0) || (minimum / (NullWindowBlocks * mean) > 0.5)) { |
|
return false; |
|
} |
|
|
|
const int64_t nullStart = m_bufferStart + searchStart + static_cast<int64_t>(minimumBlock) * NullBlock; |
|
|
|
// Fractional frequency offset from the cyclic prefix (modulo the 1 kHz carrier spacing) |
|
const std::complex<float> *frame = &m_buffer[nullStart - m_bufferStart]; |
|
const std::complex<float> cp = cyclicPrefixCorrelation(frame, 0); |
|
double frequency = -std::arg(cp) / (2.0 * Pi) * (ModeI::SampleRate / ModeI::FFTSize); |
|
|
|
// Integer offset from the phase reference symbol |
|
std::vector<std::complex<float>> prs; |
|
const int prsWindow = Margin + ModeI::NullSize + ModeI::GuardSize; |
|
|
|
mix(nullStart - Margin, ModeI::FrameSize + 2 * Margin, frequency, m_mixed); |
|
symbolFFT(&m_mixed[prsWindow], prs); |
|
|
|
float quality; |
|
const int offset = integerFrequencyOffset(prs, m_searchRange, quality); |
|
if (debugEnabled()) { |
|
std::fprintf(stderr, "acquire: fraction %.1f Hz, integer offset %d quality %.2f\n", frequency, offset, quality); |
|
} |
|
if (quality < MinAcquisitionQuality) { |
|
return false; |
|
} |
|
frequency += offset * (ModeI::SampleRate / ModeI::FFTSize); |
|
|
|
mix(nullStart - Margin, ModeI::FrameSize + 2 * Margin, frequency, m_mixed); |
|
symbolFFT(&m_mixed[prsWindow], prs); |
|
|
|
float impulseQuality; |
|
double fineTiming; |
|
const int shift = timingFromImpulseResponse(prs, impulseQuality, fineTiming); |
|
if (debugEnabled()) { |
|
std::fprintf(stderr, "acquire: timing shift %d impulse quality %.1f dB\n", shift, impulseQuality); |
|
} |
|
if (impulseQuality < MinImpulseQualityDB) { |
|
return false; |
|
} |
|
// A null at the start of the input, whose frame starts before it: take the next one |
|
if (nullStart + shift - Margin < m_bufferStart) { |
|
return false; |
|
} |
|
|
|
m_frequency = frequency; |
|
m_frameStart = nullStart + shift; |
|
m_frameStartFraction = 0.0; |
|
m_state = State::Locked; |
|
m_locks++; |
|
m_haveTiming = false; |
|
m_haveCarrierNoise = false; |
|
m_noiseFrames = 0; |
|
m_haveCarrierPower = false; |
|
m_haveLastNullDepth = false; |
|
m_haveImpulseAverage = false; |
|
std::fill(m_lastNullPower.begin(), m_lastNullPower.end(), 0.0f); |
|
m_badFrames = 0; |
|
m_integerOffsetVotes = 0; |
|
return true; |
|
} |
|
|
|
bool DABFrontEnd::processFrame() |
|
{ |
|
const int64_t frameStart = m_frameStart; |
|
const int frameLength = ModeI::FrameSize + 2 * Margin; |
|
|
|
// Track the fractional offset from the cyclic prefix of the raw input: its phase is the |
|
// total offset modulo 1 kHz, so only the integer part of the current estimate is kept. |
|
const std::complex<float> cp = cyclicPrefixCorrelation(&m_buffer[frameStart - m_bufferStart], 0); |
|
const double spacing = ModeI::SampleRate / ModeI::FFTSize; |
|
const double fraction = -std::arg(cp) / (2.0 * Pi) * spacing; |
|
double frequency = std::round((m_frequency - fraction) / spacing) * spacing + fraction; |
|
|
|
mix(frameStart - Margin, frameLength, frequency, m_mixed); |
|
|
|
std::vector<std::complex<float>> prs; |
|
const int prsWindow = Margin + ModeI::NullSize + ModeI::GuardSize; |
|
symbolFFT(&m_mixed[prsWindow], prs); |
|
|
|
// An integer carrier slip is only accepted when seen in consecutive frames |
|
float offsetQuality; |
|
const int offset = integerFrequencyOffset(prs, 2, offsetQuality); |
|
if ((offset != 0) && (offsetQuality >= MinAcquisitionQuality)) |
|
{ |
|
if (offset == m_lastIntegerOffset) { |
|
m_integerOffsetVotes++; |
|
} else { |
|
m_integerOffsetVotes = 1; |
|
} |
|
m_lastIntegerOffset = offset; |
|
if (m_integerOffsetVotes >= 3) |
|
{ |
|
frequency += offset * spacing; |
|
m_integerOffsetVotes = 0; |
|
mix(frameStart - Margin, frameLength, frequency, m_mixed); |
|
symbolFFT(&m_mixed[prsWindow], prs); |
|
} |
|
} |
|
else |
|
{ |
|
m_integerOffsetVotes = 0; |
|
} |
|
|
|
float impulseQuality; |
|
double fineTiming; |
|
int shift = timingFromImpulseResponse(prs, impulseQuality, fineTiming); |
|
|
|
const bool collapsed = m_haveImpulseAverage && (impulseQuality < m_impulseAverage - CollapseDB); |
|
if ((impulseQuality < MinTrackingQualityDB) || collapsed) |
|
{ |
|
// The frequency and timing estimates of a bad frame are not used |
|
m_badFrames++; |
|
if (debugEnabled()) { |
|
std::fprintf(stderr, "track: bad impulse response %d (quality %.1f dB, average %.1f dB, shift %d)\n", m_badFrames, |
|
impulseQuality, m_impulseAverage, shift); |
|
} |
|
if (m_badFrames >= (collapsed ? MaxCollapsedFrames : MaxBadFrames)) { |
|
if (debugEnabled()) { |
|
std::fprintf(stderr, "track: reacquire after %d bad frames\n", m_badFrames); |
|
} |
|
reacquire(); |
|
} else { |
|
m_frameStart += ModeI::FrameSize; |
|
} |
|
return false; |
|
} |
|
m_badFrames = 0; |
|
m_frequency = frequency; |
|
m_impulseAverage = m_haveImpulseAverage ? 0.9f * m_impulseAverage + 0.1f * impulseQuality : impulseQuality; |
|
m_haveImpulseAverage = true; |
|
|
|
// Large steps need to be seen twice, so that one noisy impulse response cannot move the timing |
|
if (std::abs(shift) > MaxTrackingStep) |
|
{ |
|
if ((m_pendingShift != 0) && (std::abs(shift - m_pendingShift) <= 16)) |
|
{ |
|
m_pendingShift = 0; |
|
} |
|
else |
|
{ |
|
m_pendingShift = shift; |
|
shift = 0; |
|
} |
|
} |
|
else |
|
{ |
|
m_pendingShift = 0; |
|
} |
|
|
|
// Sample clock: the drift of the mean channel delay from frame to frame |
|
const double timing = static_cast<double>(frameStart) + fineTiming; |
|
if (m_haveTiming) |
|
{ |
|
const double drift = timing - m_lastFineTiming - ModeI::FrameSize; |
|
if (std::abs(drift) < 40.0) |
|
{ |
|
m_driftPerFrame = 0.9f * m_driftPerFrame + 0.1f * static_cast<float>(drift); |
|
m_clockErrorPPM = m_driftPerFrame / ModeI::FrameSize * 1.0e6f; |
|
} |
|
} |
|
m_lastFineTiming = timing; |
|
m_haveTiming = true; |
|
|
|
if (shift != 0) { |
|
symbolFFT(&m_mixed[prsWindow + shift], prs); |
|
} |
|
|
|
// FFT of every symbol, correcting the timing drift within the frame |
|
for (int l = 1; l <= ModeI::SymbolsPerFrame; l++) |
|
{ |
|
const int window = Margin + shift + ModeI::NullSize + (l - 1) * ModeI::SymbolSize + ModeI::GuardSize; |
|
std::vector<std::complex<float>>& symbol = m_symbols[l - 1]; |
|
|
|
if (l == 1) { |
|
symbol = prs; |
|
} else { |
|
symbolFFT(&m_mixed[window], symbol); |
|
} |
|
|
|
const float tau = m_driftPerFrame * static_cast<float>((l - 1) * ModeI::SymbolSize) / ModeI::FrameSize; |
|
if (std::abs(tau) > 0.001f) |
|
{ |
|
// A phase slope across the carriers, by recurrence from the lowest carrier |
|
const double step = 2.0 * Pi * tau / ModeI::FFTSize; |
|
const std::complex<float> increment(static_cast<float>(std::cos(step)), static_cast<float>(std::sin(step))); |
|
std::complex<float> rotation(static_cast<float>(std::cos(step * (-ModeI::Carriers / 2))), |
|
static_cast<float>(std::sin(step * (-ModeI::Carriers / 2)))); |
|
for (int k = -ModeI::Carriers / 2; k <= ModeI::Carriers / 2; k++) |
|
{ |
|
symbol[binForCarrier(k)] *= rotation; |
|
rotation *= increment; |
|
} |
|
} |
|
} |
|
|
|
// Null symbol: spectrum for TII, and the noise of each carrier |
|
const int nullWindow = Margin + shift + (ModeI::NullSize - ModeI::FFTSize) / 2; |
|
std::vector<std::complex<float>> nullFFT; |
|
symbolFFT(&m_mixed[nullWindow], nullFFT); |
|
for (int i = 0; i < ModeI::FFTSize; i++) { |
|
m_frame.nullSpectrum[i] = std::norm(nullFFT[i]); |
|
} |
|
estimateNoise(nullFFT); |
|
|
|
demodulate(); |
|
carrierToNoise(); |
|
|
|
double nullPower = 0.0; |
|
for (int n = 64; n < ModeI::NullSize - 64; n++) { |
|
nullPower += std::norm(m_mixed[Margin + shift + n]); |
|
} |
|
nullPower /= (ModeI::NullSize - 128); |
|
double symbolPower = 0.0; |
|
for (int n = ModeI::NullSize; n < ModeI::FrameSize; n += 7) { |
|
symbolPower += std::norm(m_mixed[Margin + shift + n]); |
|
} |
|
symbolPower /= (ModeI::FrameSize - ModeI::NullSize) / 7; |
|
|
|
m_frame.startSample = frameStart + shift; |
|
m_frame.frequencyOffsetHz = static_cast<float>(m_frequency); |
|
m_frame.clockErrorPPM = m_clockErrorPPM; |
|
// TII carriers are in the null of alternate frames only: the lower of two frames is the |
|
// null without them |
|
const float nullDepth = (nullPower > 0.0 && symbolPower > 0.0) ? static_cast<float>(10.0 * std::log10(nullPower / symbolPower)) : 0.0f; |
|
m_frame.nullDepthDB = m_haveLastNullDepth ? std::min(nullDepth, m_lastNullDepth) : nullDepth; |
|
m_lastNullDepth = nullDepth; |
|
m_haveLastNullDepth = true; |
|
m_frame.prsQualityDB = impulseQuality; |
|
m_frame.timingAdjustment = shift; |
|
|
|
// Next frame, including the measured clock drift |
|
m_frameStartFraction += m_driftPerFrame; |
|
const int64_t whole = static_cast<int64_t>(std::floor(m_frameStartFraction)); |
|
m_frameStartFraction -= static_cast<double>(whole); |
|
m_frameStart = frameStart + shift + ModeI::FrameSize + whole; |
|
|
|
if (m_frameCallback) { |
|
m_frameCallback(m_frame); |
|
} |
|
return true; |
|
} |
|
|
|
void DABFrontEnd::estimateNoise(const std::vector<std::complex<float>>& nullSymbol) |
|
{ |
|
DABProfileScope profile(DABProfile::Demodulation); |
|
// TII carriers are on in alternate frames only: the lower power of two consecutive |
|
// frames leaves the noise and interference |
|
std::vector<float> power(ModeI::Carriers); |
|
|
|
for (int k = -ModeI::Carriers / 2; k <= ModeI::Carriers / 2; k++) |
|
{ |
|
if (k == 0) { |
|
continue; |
|
} |
|
const int c = carrierIndex(k); |
|
const float p = std::norm(nullSymbol[binForCarrier(k)]); |
|
power[c] = std::min(p, m_lastNullPower[c]); |
|
m_lastNullPower[c] = p; |
|
} |
|
|
|
// Smooth across neighbouring carriers, then over frames |
|
for (int c = 0; c < ModeI::Carriers; c++) |
|
{ |
|
const float sum = power[std::max(0, c - 1)] + power[c] + power[std::min(ModeI::Carriers - 1, c + 1)]; |
|
const float smoothed = sum / 3.0f; |
|
if (m_haveCarrierNoise) { |
|
m_carrierNoise[c] = 0.9f * m_carrierNoise[c] + 0.1f * smoothed; |
|
} else { |
|
m_carrierNoise[c] = smoothed; |
|
} |
|
} |
|
// The first frame has no previous null to compare with |
|
static const int warmUp = 2; |
|
if (m_noiseFrames < warmUp) { |
|
m_noiseFrames++; |
|
} |
|
m_haveCarrierNoise = m_noiseFrames >= warmUp; |
|
} |
|
|
|
void DABFrontEnd::carrierToNoise() |
|
{ |
|
// Each carrier's mean power over the frame (signal and noise), smoothed over frames |
|
for (int c = 0; c < ModeI::Carriers; c++) |
|
{ |
|
const int bin = c < ModeI::Carriers / 2 ? c + ModeI::FFTSize - ModeI::Carriers / 2 : c - ModeI::Carriers / 2 + 1; |
|
float power = 0.0f; |
|
for (int l = 0; l < ModeI::SymbolsPerFrame; l++) { |
|
power += std::norm(m_symbols[l][bin]); |
|
} |
|
power /= ModeI::SymbolsPerFrame; |
|
m_carrierPower[c] = m_haveCarrierPower ? 0.9f * m_carrierPower[c] + 0.1f * power : power; |
|
} |
|
m_haveCarrierPower = true; |
|
|
|
// The noise estimate is the lower of two nulls (to remove TII), which halves noise on |
|
// average, so it is doubled here |
|
m_frame.carrierCN.resize(ModeI::Carriers); |
|
for (int c = 0; c < ModeI::Carriers; c++) |
|
{ |
|
const float n = 2.0f * std::max(m_carrierNoise[c], 1.0e-30f); |
|
const float s = std::max(m_carrierPower[c] - n, 1.0e-3f * n); |
|
m_frame.carrierCN[c] = 10.0f * std::log10(s / n); |
|
} |
|
// The median carrier: a strong interferer on a few carriers, which the decoder copes |
|
// with, shows in the carriers' C/N rather than dominating this |
|
if (m_haveCarrierNoise) |
|
{ |
|
std::vector<float> sorted = m_frame.carrierCN; |
|
std::nth_element(sorted.begin(), sorted.begin() + ModeI::Carriers / 2, sorted.end()); |
|
m_frame.cnDB = sorted[ModeI::Carriers / 2]; |
|
} |
|
else |
|
{ |
|
m_frame.cnDB = 0.0f; |
|
} |
|
} |
|
|
|
void DABFrontEnd::demodulate() |
|
{ |
|
DABProfileScope profile(DABProfile::Demodulation); |
|
const int differentialSymbols = ModeI::SymbolsPerFrame - 1; |
|
std::vector<std::complex<float>>& differential = m_differential; |
|
std::vector<float> sumAbs(ModeI::Carriers, 0.0f); |
|
std::vector<float> sumAbsSquared(ModeI::Carriers, 0.0f); |
|
// Carriers -768..-1 are bins 1280..2047 and carriers 1..768 bins 1..768 |
|
const int firstBin[2] = {ModeI::FFTSize - ModeI::Carriers / 2, 1}; |
|
|
|
for (int l = 2; l <= ModeI::SymbolsPerFrame; l++) |
|
{ |
|
const float *current = reinterpret_cast<const float *>(m_symbols[l - 1].data()); |
|
const float *previous = reinterpret_cast<const float *>(m_symbols[l - 2].data()); |
|
float *d = reinterpret_cast<float *>(&differential[(l - 2) * ModeI::Carriers]); |
|
|
|
for (int half = 0; half < 2; half++) |
|
{ |
|
const float *x = ¤t[2 * firstBin[half]]; |
|
const float *y = &previous[2 * firstBin[half]]; |
|
float *out = &d[2 * half * (ModeI::Carriers / 2)]; |
|
float *sa = &sumAbs[half * (ModeI::Carriers / 2)]; |
|
float *sq = &sumAbsSquared[half * (ModeI::Carriers / 2)]; |
|
|
|
for (int i = 0; i < ModeI::Carriers / 2; i++) |
|
{ |
|
// x * conj(y) |
|
const float re = x[2 * i] * y[2 * i] + x[2 * i + 1] * y[2 * i + 1]; |
|
const float im = x[2 * i + 1] * y[2 * i] - x[2 * i] * y[2 * i + 1]; |
|
out[2 * i] = re; |
|
out[2 * i + 1] = im; |
|
const float ar = std::abs(re); |
|
const float ai = std::abs(im); |
|
sa[i] += ar + ai; |
|
sq[i] += ar * ar + ai * ai; |
|
} |
|
} |
|
} |
|
|
|
// MER: each component's mean amplitude and its variance about it |
|
const double n = 2.0 * differentialSymbols; |
|
double signal = 0.0; |
|
double noise = 0.0; |
|
|
|
for (int c = 0; c < ModeI::Carriers; c++) |
|
{ |
|
const double mu = sumAbs[c] / n; |
|
signal += mu * mu; |
|
noise += std::max(sumAbsSquared[c] / n - mu * mu, 1.0e-30); |
|
} |
|
m_frame.merDB = noise > 0.0 ? static_cast<float>(10.0 * std::log10(signal / noise)) : 0.0f; |
|
// The differential product has twice the noise of a symbol |
|
m_frame.snrDB = m_frame.merDB + 3.01f; |
|
|
|
// The real part of the differential product is the optimum metric when the noise is the |
|
// same on every carrier (its amplitude already follows the channel). Carriers with more |
|
// noise, from interference, are weighted down in proportion. |
|
std::vector<float> weight(ModeI::Carriers, 1.0f); |
|
if (m_haveCarrierNoise) |
|
{ |
|
std::vector<float> sorted = m_carrierNoise; |
|
std::nth_element(sorted.begin(), sorted.begin() + ModeI::Carriers / 2, sorted.end()); |
|
const float reference = sorted[ModeI::Carriers / 2]; |
|
for (int c = 0; c < ModeI::Carriers; c++) { |
|
weight[c] = std::max(1.0e-3f, std::min(2.0f, reference / std::max(m_carrierNoise[c], 1.0e-30f))); |
|
} |
|
} |
|
|
|
// Carriers in carrier index order, for three-symbol detection and the coherent pass |
|
auto carrier = [this](int l, int c) -> const std::complex<float>& { |
|
return m_symbols[l - 1][c < ModeI::Carriers / 2 ? c + ModeI::FFTSize - ModeI::Carriers / 2 : c - ModeI::Carriers / 2 + 1]; |
|
}; |
|
|
|
if (m_exportCarriers) |
|
{ |
|
m_frame.carriers.resize(ModeI::SymbolsPerFrame * ModeI::Carriers); |
|
for (int l = 1; l <= ModeI::SymbolsPerFrame; l++) |
|
{ |
|
for (int c = 0; c < ModeI::Carriers; c++) { |
|
m_frame.carriers[(l - 1) * ModeI::Carriers + c] = carrier(l, c); |
|
} |
|
} |
|
m_frame.weights = weight; |
|
} |
|
else |
|
{ |
|
m_frame.carriers.clear(); |
|
m_frame.weights.clear(); |
|
} |
|
|
|
const std::complex<float> *source = differential.data(); |
|
if (m_detection == Detection::ThreeSymbol) |
|
{ |
|
// Noncoherent detection over symbols l-2, l-1 and l: the metric of hypotheses |
|
// y(l-1) = q(a), y(l) = q(c) is |r(l-2) + r(l-1) conj(q(a)) + r(l) conj(q(a) q(c))|^2. |
|
// Each bit's soft value is the best metric with the bit 0 less the best with it 1, |
|
// scaled so that the two symbol case gives Re/Im of the differential product. |
|
// q(a) = exp(j (pi/4 + a pi/2)), so q(a) q(c) is a multiple of j: conj of it rotates |
|
// r(l) by -90 degrees (a + c + 1) times. |
|
m_threeSymbol.resize(differential.size()); |
|
const float a = 1.0f / std::sqrt(2.0f); |
|
const float scale = 1.0f / (2.0f * std::sqrt(2.0f)); |
|
// Symbol 2 has only the phase reference before it |
|
std::copy(differential.begin(), differential.begin() + ModeI::Carriers, m_threeSymbol.begin()); |
|
|
|
for (int l = 3; l <= ModeI::SymbolsPerFrame; l++) |
|
{ |
|
std::complex<float> *out = &m_threeSymbol[(l - 2) * ModeI::Carriers]; |
|
for (int c = 0; c < ModeI::Carriers; c++) |
|
{ |
|
const std::complex<float> A = carrier(l - 2, c); |
|
const std::complex<float> B = carrier(l - 1, c); |
|
const std::complex<float> C = carrier(l, c); |
|
// B conj(q(a)) |
|
const std::complex<float> Bq[4] = { |
|
std::complex<float>(a * (B.real() + B.imag()), a * (B.imag() - B.real())), |
|
std::complex<float>(a * (-B.real() + B.imag()), a * (-B.imag() - B.real())), |
|
std::complex<float>(a * (-B.real() - B.imag()), a * (-B.imag() + B.real())), |
|
std::complex<float>(a * (B.real() - B.imag()), a * (B.imag() + B.real())) |
|
}; |
|
// C (-j)^k |
|
const std::complex<float> Cr[4] = { |
|
C, |
|
std::complex<float>(C.imag(), -C.real()), |
|
-C, |
|
std::complex<float>(-C.imag(), C.real()) |
|
}; |
|
float best[4] = {-1.0e30f, -1.0e30f, -1.0e30f, -1.0e30f}; // By c |
|
for (int h = 0; h < 4; h++) |
|
{ |
|
const std::complex<float> AB = A + Bq[h]; |
|
for (int q = 0; q < 4; q++) { |
|
best[q] = std::max(best[q], std::norm(AB + Cr[(h + q + 1) & 3])); |
|
} |
|
} |
|
// Real part positive for c = 0, 3; imaginary part positive for c = 0, 1 |
|
out[c] = std::complex<float>( |
|
scale * (std::max(best[0], best[3]) - std::max(best[1], best[2])), |
|
scale * (std::max(best[0], best[1]) - std::max(best[2], best[3]))); |
|
} |
|
} |
|
source = m_threeSymbol.data(); |
|
} |
|
|
|
// Soft bits, in the order of the QPSK symbols before frequency interleaving |
|
double sumSoft = 0.0; |
|
for (int l = 2; l <= ModeI::SymbolsPerFrame; l++) |
|
{ |
|
const std::complex<float> *d = &source[(l - 2) * ModeI::Carriers]; |
|
float *out = (l <= 1 + ModeI::FICSymbols) |
|
? &m_frame.ficSoft[(l - 2) * ModeI::BitsPerSymbol] |
|
: &m_frame.mscSoft[(l - 2 - ModeI::FICSymbols) * ModeI::BitsPerSymbol]; |
|
float symbolSum = 0.0f; |
|
|
|
for (int i = 0; i < ModeI::Carriers; i++) |
|
{ |
|
const int c = m_softCarrier[i]; |
|
const float re = d[c].real() * weight[c]; |
|
const float im = d[c].imag() * weight[c]; |
|
out[i] = re; |
|
out[i + ModeI::Carriers] = im; |
|
symbolSum += std::abs(re) + std::abs(im); |
|
} |
|
sumSoft += symbolSum; |
|
} |
|
|
|
// Limit outliers (impulsive interference) to a few times the mean magnitude |
|
const float limit = static_cast<float>(8.0 * sumSoft / (2.0 * differentialSymbols * ModeI::Carriers)); |
|
if (limit > 0.0f) |
|
{ |
|
for (float& v : m_frame.ficSoft) { |
|
v = std::max(-limit, std::min(limit, v)); |
|
} |
|
for (float& v : m_frame.mscSoft) { |
|
v = std::max(-limit, std::min(limit, v)); |
|
} |
|
} |
|
} |
|
|
|
} // namespace modemdab
|
|
|