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.
436 lines
12 KiB
436 lines
12 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 // |
|
// // |
|
// Experimental FT4 decoder scaffold derived from FT8 decoder architecture. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <array> |
|
#include <cmath> |
|
#include <algorithm> |
|
|
|
#include <QThread> |
|
|
|
#include "ft4.h" |
|
#include "fft.h" |
|
#include "libldpc.h" |
|
#include "osd.h" |
|
|
|
namespace FT8 { |
|
|
|
namespace { |
|
|
|
constexpr int kFT4SymbolSamples = 576; |
|
constexpr int kFT4TotalSymbols = 103; |
|
constexpr int kFT4FrameSamples = kFT4TotalSymbols * kFT4SymbolSamples; |
|
|
|
const std::array<std::array<int, 4>, 4> kFT4SyncTones = {{ |
|
{{0, 1, 3, 2}}, |
|
{{1, 0, 2, 3}}, |
|
{{2, 3, 1, 0}}, |
|
{{3, 2, 0, 1}} |
|
}}; |
|
|
|
const std::array<int, 77> kFT4Rvec = {{ |
|
0,1,0,0,1,0,1,0,0,1,0,1,1,1,1,0,1,0,0,0,1,0,0,1,1,0,1,1,0, |
|
1,0,0,1,0,1,1,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,1,1,0,0,1,0,1, |
|
0,1,0,1,0,1,1,0,1,1,1,1,1,0,0,0,1,0,1 |
|
}}; |
|
|
|
struct FT4Candidate |
|
{ |
|
int frameIndex; |
|
int start; |
|
int toneBin; |
|
float sync; |
|
float noise; |
|
float score; |
|
}; |
|
|
|
class FT4Worker : public QObject |
|
{ |
|
public: |
|
FT4Worker( |
|
const std::vector<float>& samples, |
|
float minHz, |
|
float maxHz, |
|
int start, |
|
int rate, |
|
CallbackInterface *cb, |
|
const FT4Params& params |
|
) : |
|
m_samples(samples), |
|
m_minHz(minHz), |
|
m_maxHz(maxHz), |
|
m_start(start), |
|
m_rate(rate), |
|
m_cb(cb), |
|
m_params(params) |
|
{} |
|
|
|
void start_work() |
|
{ |
|
decode(); |
|
} |
|
|
|
private: |
|
static float binPower(const FFTEngine::ffts_t& bins, int symbolIndex, int toneBin) |
|
{ |
|
return std::abs(bins[symbolIndex][toneBin]); |
|
} |
|
|
|
void collectSyncMetrics(const FFTEngine::ffts_t& bins, int toneBin, float& sync, float& noise) const |
|
{ |
|
sync = 0.0f; |
|
noise = 0.0f; |
|
|
|
for (int block = 0; block < 4; block++) |
|
{ |
|
const int symbolOffset = block * 33; |
|
|
|
for (int index = 0; index < 4; index++) |
|
{ |
|
const int symbolIndex = symbolOffset + index; |
|
const int expectedTone = kFT4SyncTones[block][index]; |
|
|
|
for (int tone = 0; tone < 4; tone++) |
|
{ |
|
const float power = binPower(bins, symbolIndex, toneBin + tone); |
|
|
|
if (tone == expectedTone) { |
|
sync += power; |
|
} else { |
|
noise += power; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
int refineToneBin(const FFTEngine::ffts_t& bins, int toneBin) const |
|
{ |
|
float bestSync = -1.0f; |
|
int bestToneBin = toneBin; |
|
|
|
for (int delta = -1; delta <= 1; delta++) |
|
{ |
|
int candidateToneBin = toneBin + delta; |
|
|
|
if (candidateToneBin < 0) { |
|
continue; |
|
} |
|
|
|
float sync = 0.0f; |
|
float noise = 0.0f; |
|
collectSyncMetrics(bins, candidateToneBin, sync, noise); |
|
|
|
if (sync > bestSync) |
|
{ |
|
bestSync = sync; |
|
bestToneBin = candidateToneBin; |
|
} |
|
} |
|
|
|
return bestToneBin; |
|
} |
|
|
|
void buildBitMetrics(const FFTEngine::ffts_t& bins, int toneBin, std::array<float, 174>& bitMetrics) const |
|
{ |
|
int bitIndex = 0; |
|
|
|
for (int symbolIndex = 0; symbolIndex < kFT4TotalSymbols; symbolIndex++) |
|
{ |
|
const bool inSync = (symbolIndex < 4) |
|
|| (symbolIndex >= 33 && symbolIndex < 37) |
|
|| (symbolIndex >= 66 && symbolIndex < 70) |
|
|| (symbolIndex >= 99); |
|
|
|
if (inSync) { |
|
continue; |
|
} |
|
|
|
std::array<float, 4> tonePower; |
|
|
|
for (int tone = 0; tone < 4; tone++) { |
|
tonePower[tone] = binPower(bins, symbolIndex, toneBin + tone); |
|
} |
|
|
|
const float b0Zero = std::max(tonePower[0], tonePower[1]); |
|
const float b0One = std::max(tonePower[2], tonePower[3]); |
|
const float b1Zero = std::max(tonePower[0], tonePower[3]); |
|
const float b1One = std::max(tonePower[1], tonePower[2]); |
|
|
|
bitMetrics[bitIndex++] = b0Zero - b0One; |
|
bitMetrics[bitIndex++] = b1Zero - b1One; |
|
} |
|
} |
|
|
|
FFTEngine::ffts_t makeFrameBins(int start) |
|
{ |
|
return m_fftEngine.ffts(m_samples, start, kFT4SymbolSamples); |
|
} |
|
|
|
void decode() |
|
{ |
|
if (m_samples.size() < kFT4FrameSamples) { |
|
return; |
|
} |
|
|
|
const int maxStart = static_cast<int>(m_samples.size()) - kFT4FrameSamples; |
|
const float binSpacing = static_cast<float>(m_rate) / static_cast<float>(kFT4SymbolSamples); |
|
|
|
if (m_maxHz <= m_minHz) { |
|
return; |
|
} |
|
|
|
std::vector<int> startCandidates; |
|
|
|
auto addStartCandidate = [&](int start) |
|
{ |
|
start = std::max(0, std::min(start, maxStart)); |
|
|
|
if (std::find(startCandidates.begin(), startCandidates.end(), start) == startCandidates.end()) { |
|
startCandidates.push_back(start); |
|
} |
|
}; |
|
|
|
for (int start = 0; start <= std::min(maxStart, 14000); start += kFT4SymbolSamples) { |
|
addStartCandidate(start); |
|
} |
|
|
|
const int nominalStart = maxStart / 2; |
|
addStartCandidate(std::max(0, nominalStart - 2 * kFT4SymbolSamples)); |
|
addStartCandidate(std::max(0, nominalStart - kFT4SymbolSamples)); |
|
addStartCandidate(nominalStart); |
|
addStartCandidate(std::min(maxStart, nominalStart + kFT4SymbolSamples)); |
|
addStartCandidate(std::min(maxStart, nominalStart + 2 * kFT4SymbolSamples)); |
|
addStartCandidate(maxStart); |
|
|
|
struct FT4Frame |
|
{ |
|
int start; |
|
FFTEngine::ffts_t bins; |
|
}; |
|
|
|
std::vector<FT4Frame> frames; |
|
frames.reserve(startCandidates.size()); |
|
|
|
for (int start : startCandidates) |
|
{ |
|
FFTEngine::ffts_t bins = makeFrameBins(start); |
|
|
|
if (bins.size() < kFT4TotalSymbols) { |
|
continue; |
|
} |
|
|
|
if (bins[0].size() < 8) { |
|
continue; |
|
} |
|
|
|
frames.push_back(FT4Frame{start, std::move(bins)}); |
|
} |
|
|
|
if (frames.empty()) { |
|
return; |
|
} |
|
|
|
const int minToneBin = std::max(0, static_cast<int>(std::ceil(m_minHz / binSpacing))); |
|
const int maxToneBinByHz = static_cast<int>(std::floor(m_maxHz / binSpacing)) - 3; |
|
|
|
if (maxToneBinByHz < minToneBin) { |
|
return; |
|
} |
|
|
|
std::vector<FT4Candidate> candidates; |
|
|
|
for (int frameIndex = 0; frameIndex < static_cast<int>(frames.size()); frameIndex++) |
|
{ |
|
const FT4Frame& frame = frames[frameIndex]; |
|
const int maxToneBin = std::min(maxToneBinByHz, static_cast<int>(frame.bins[0].size()) - 4); |
|
|
|
for (int toneBin = minToneBin; toneBin <= maxToneBin; toneBin++) |
|
{ |
|
float sync = 0.0f; |
|
float noise = 0.0f; |
|
collectSyncMetrics(frame.bins, toneBin, sync, noise); |
|
const float score = sync - 1.25f * (noise / 3.0f); |
|
candidates.push_back(FT4Candidate{frameIndex, frame.start, toneBin, sync, noise, score}); |
|
} |
|
} |
|
|
|
if (candidates.empty()) { |
|
return; |
|
} |
|
|
|
std::sort(candidates.begin(), candidates.end(), [](const FT4Candidate& lhs, const FT4Candidate& rhs) { |
|
return lhs.score > rhs.score; |
|
}); |
|
|
|
const int maxDecodeCandidates = std::min(m_params.max_candidates, static_cast<int>(candidates.size())); |
|
const int ldpcThreshold = std::max(48, m_params.osd_ldpc_thresh - 18); |
|
|
|
for (int candidateIndex = 0; candidateIndex < maxDecodeCandidates; candidateIndex++) |
|
{ |
|
const FT4Candidate& candidate = candidates[candidateIndex]; |
|
const FT4Frame& frame = frames[candidate.frameIndex]; |
|
const int refinedToneBin = refineToneBin(frame.bins, candidate.toneBin); |
|
std::array<float, 174> llr; |
|
buildBitMetrics(frame.bins, refinedToneBin, llr); |
|
|
|
int plain[174]; |
|
int ldpcOk = 0; |
|
LDPC::ldpc_decode(llr.data(), m_params.ldpc_iters, plain, &ldpcOk); |
|
|
|
if (ldpcOk < ldpcThreshold) { |
|
continue; |
|
} |
|
|
|
int a174[174]; |
|
|
|
for (int i = 0; i < 174; i++) { |
|
a174[i] = plain[i]; |
|
} |
|
|
|
bool crcOk = OSD::check_crc(a174); |
|
|
|
if (!crcOk && m_params.use_osd) |
|
{ |
|
int oplain[91]; |
|
int depth = -1; |
|
std::array<float, 174> llrCopy = llr; |
|
|
|
if (OSD::osd_decode(llrCopy.data(), m_params.osd_depth, oplain, &depth)) |
|
{ |
|
OSD::ldpc_encode(oplain, a174); |
|
crcOk = OSD::check_crc(a174); |
|
} |
|
} |
|
|
|
if (!crcOk) { |
|
continue; |
|
} |
|
|
|
int a91[91]; |
|
|
|
for (int i = 0; i < 91; i++) { |
|
a91[i] = a174[i]; |
|
} |
|
|
|
for (int i = 0; i < 77; i++) { |
|
a91[i] ^= kFT4Rvec[i]; |
|
} |
|
|
|
const float snrLinear = (candidate.sync + 1.0e-9f) / ((candidate.noise / 3.0f) + 1.0e-9f); |
|
const float snr = 10.0f * std::log10(snrLinear) - 12.0f; |
|
const float off = static_cast<float>(m_start) / m_rate + static_cast<float>(candidate.start) / m_rate; |
|
const float tone0 = refinedToneBin * binSpacing; |
|
m_cb->hcb(a91, tone0, off, "FT4-EXP", snr, 0, ldpcOk); |
|
} |
|
} |
|
|
|
std::vector<float> m_samples; |
|
float m_minHz; |
|
float m_maxHz; |
|
int m_start; |
|
int m_rate; |
|
CallbackInterface *m_cb; |
|
FT4Params m_params; |
|
FFTEngine m_fftEngine; |
|
}; |
|
|
|
} // namespace |
|
|
|
FT4Decoder::~FT4Decoder() |
|
{ |
|
forceQuit(); |
|
} |
|
|
|
void FT4Decoder::entry( |
|
float xsamples[], |
|
int nsamples, |
|
int start, |
|
int rate, |
|
float min_hz, |
|
float max_hz, |
|
int hints1[], |
|
int hints2[], |
|
double time_left, |
|
double total_time_left, |
|
CallbackInterface *cb, |
|
int nprevdecs, |
|
struct cdecode *xprevdecs |
|
) |
|
{ |
|
(void) hints1; |
|
(void) hints2; |
|
(void) time_left; |
|
(void) total_time_left; |
|
(void) nprevdecs; |
|
(void) xprevdecs; |
|
|
|
std::vector<float> samples(nsamples); |
|
|
|
for (int i = 0; i < nsamples; i++) { |
|
samples[i] = xsamples[i]; |
|
} |
|
|
|
if (min_hz < 0) { |
|
min_hz = 0; |
|
} |
|
|
|
if (max_hz > rate / 2) { |
|
max_hz = rate / 2; |
|
} |
|
|
|
const float per = (max_hz - min_hz) / params.nthreads; |
|
|
|
for (int i = 0; i < params.nthreads; i++) |
|
{ |
|
float hz0 = min_hz + i * per; |
|
float hz1 = min_hz + (i + 1) * per; |
|
hz0 = std::max(hz0, 0.0f); |
|
hz1 = std::min(hz1, (rate / 2.0f) - 50.0f); |
|
|
|
FT4Worker *ft4 = new FT4Worker(samples, hz0, hz1, start, rate, cb, params); |
|
QThread *th = new QThread(); |
|
th->setObjectName(QString("ft4:%1:%2").arg(cb->get_name()).arg(i)); |
|
threads.push_back(th); |
|
ft4->moveToThread(th); |
|
QObject::connect(th, &QThread::started, ft4, [ft4, th]() { |
|
ft4->start_work(); |
|
th->quit(); |
|
}); |
|
QObject::connect(th, &QThread::finished, ft4, &QObject::deleteLater); |
|
QObject::connect(th, &QThread::finished, th, &QObject::deleteLater); |
|
th->start(); |
|
} |
|
} |
|
|
|
void FT4Decoder::wait(double time_left) |
|
{ |
|
unsigned long thread_timeout = time_left * 1000; |
|
|
|
while (!threads.empty()) |
|
{ |
|
bool success = threads.front()->wait(thread_timeout); |
|
|
|
if (!success) |
|
{ |
|
qDebug("FT8::FT4Decoder::wait: thread timed out"); |
|
thread_timeout = 50; |
|
} |
|
|
|
threads.erase(threads.begin()); |
|
} |
|
} |
|
|
|
void FT4Decoder::forceQuit() |
|
{ |
|
while (!threads.empty()) |
|
{ |
|
threads.front()->quit(); |
|
threads.front()->wait(); |
|
threads.erase(threads.begin()); |
|
} |
|
} |
|
|
|
} // namespace FT8
|
|
|