7 changed files with 4 additions and 751 deletions
@ -1,436 +0,0 @@
@@ -1,436 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2026 Edouard Griffiths, F4EXB <f4exb06@gmail.com> //
|
||||
// //
|
||||
// This is the code from ft8mon: https://github.com/rtmrtmrtmrtm/ft8mon //
|
||||
// reformatted and adapted to Qt and SDRangel context //
|
||||
// //
|
||||
// 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 "libldpc.h" |
||||
#include "osd.h" |
||||
#include "ft4worker.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; |
||||
}; |
||||
|
||||
} |
||||
|
||||
|
||||
FT4Worker::FT4Worker( |
||||
const std::vector<float>& samples, |
||||
float minHz, |
||||
float maxHz, |
||||
int start, |
||||
int rate, |
||||
CallbackInterface *cb, |
||||
const FT4ParamsLight& params |
||||
) : |
||||
m_samples(samples), |
||||
m_minHz(minHz), |
||||
m_maxHz(maxHz), |
||||
m_start(start), |
||||
m_rate(rate), |
||||
m_cb(cb), |
||||
m_params(params) |
||||
{} |
||||
|
||||
void FT4Worker::start_work() |
||||
{ |
||||
decode(); |
||||
} |
||||
|
||||
float FT4Worker::binPowerInterpolated(const FFTEngine::ffts_t& bins, int symbolIndex, float toneBin) |
||||
{ |
||||
const int binCount = bins[symbolIndex].size(); |
||||
|
||||
if (binCount <= 0) { |
||||
return 0.0f; |
||||
} |
||||
|
||||
if (toneBin <= 0.0f) { |
||||
return std::abs(bins[symbolIndex][0]); |
||||
} |
||||
|
||||
if (toneBin >= static_cast<float>(binCount - 1)) { |
||||
return std::abs(bins[symbolIndex][binCount - 1]); |
||||
} |
||||
|
||||
const int lowerBin = static_cast<int>(std::floor(toneBin)); |
||||
const int upperBin = lowerBin + 1; |
||||
const float frac = toneBin - lowerBin; |
||||
const float p0 = std::abs(bins[symbolIndex][lowerBin]); |
||||
const float p1 = std::abs(bins[symbolIndex][upperBin]); |
||||
return p0 + frac * (p1 - p0); |
||||
} |
||||
|
||||
void FT4Worker::collectSyncMetrics(const FFTEngine::ffts_t& bins, float 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 = binPowerInterpolated(bins, symbolIndex, toneBin + tone); |
||||
|
||||
if (tone == expectedTone) { |
||||
sync += power; |
||||
} else { |
||||
noise += power; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
float FT4Worker::refineToneBin(const FFTEngine::ffts_t& bins, int toneBin) const |
||||
{ |
||||
auto scoreAt = [&](float candidateToneBin) { |
||||
float sync = 0.0f; |
||||
float noise = 0.0f; |
||||
collectSyncMetrics(bins, candidateToneBin, sync, noise); |
||||
return sync - 0.9f * (noise / 3.0f); |
||||
}; |
||||
|
||||
const float left = scoreAt(toneBin - 1.0f); |
||||
const float center = scoreAt(toneBin); |
||||
const float right = scoreAt(toneBin + 1.0f); |
||||
const float denom = left - 2.0f * center + right; |
||||
float frac = 0.0f; |
||||
|
||||
if (std::fabs(denom) > 1.0e-12f) { |
||||
frac = 0.5f * (left - right) / denom; |
||||
} |
||||
|
||||
if (frac > 0.5f) { |
||||
frac = 0.5f; |
||||
} else if (frac < -0.5f) { |
||||
frac = -0.5f; |
||||
} |
||||
|
||||
return toneBin + frac; |
||||
} |
||||
|
||||
void FT4Worker::buildBitMetrics(const FFTEngine::ffts_t& bins, float toneBin, std::array<float, 174>& bitMetrics) const |
||||
{ |
||||
int bitIndex = 0; |
||||
float llrAbsSum = 0.0f; |
||||
|
||||
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] = binPowerInterpolated(bins, symbolIndex, toneBin + tone); |
||||
} |
||||
|
||||
const float epsilon = 1.0e-6f; |
||||
const float b0Zero = std::max(tonePower[0], tonePower[1]) + epsilon; |
||||
const float b0One = std::max(tonePower[2], tonePower[3]) + epsilon; |
||||
const float b1Zero = std::max(tonePower[0], tonePower[3]) + epsilon; |
||||
const float b1One = std::max(tonePower[1], tonePower[2]) + epsilon; |
||||
|
||||
const float llr0 = std::log(b0Zero / b0One); |
||||
const float llr1 = std::log(b1Zero / b1One); |
||||
|
||||
bitMetrics[bitIndex++] = llr0; |
||||
bitMetrics[bitIndex++] = llr1; |
||||
llrAbsSum += std::fabs(llr0) + std::fabs(llr1); |
||||
} |
||||
|
||||
if (bitIndex <= 0) { |
||||
return; |
||||
} |
||||
|
||||
const float meanAbs = llrAbsSum / bitIndex; |
||||
|
||||
if (meanAbs < 1.0e-5f) { |
||||
return; |
||||
} |
||||
|
||||
const float targetMean = 3.0f; |
||||
const float globalScale = targetMean / meanAbs; |
||||
|
||||
for (int i = 0; i < bitIndex; i++) { |
||||
float scaled = bitMetrics[i] * globalScale; |
||||
|
||||
if (scaled > 8.0f) { |
||||
scaled = 8.0f; |
||||
} else if (scaled < -8.0f) { |
||||
scaled = -8.0f; |
||||
} |
||||
|
||||
bitMetrics[i] = scaled; |
||||
} |
||||
} |
||||
|
||||
FFTEngine::ffts_t FT4Worker::makeFrameBins(int start) |
||||
{ |
||||
return m_fftEngine.ffts(m_samples, start, kFT4SymbolSamples); |
||||
} |
||||
|
||||
void FT4Worker::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> coarseStarts; |
||||
std::vector<int> startCandidates; |
||||
|
||||
auto addCoarseStart = [&](int start) |
||||
{ |
||||
start = std::max(0, std::min(start, maxStart)); |
||||
|
||||
if (std::find(coarseStarts.begin(), coarseStarts.end(), start) == coarseStarts.end()) { |
||||
coarseStarts.push_back(start); |
||||
} |
||||
}; |
||||
|
||||
for (int start = 0; start <= std::min(maxStart, 14000); start += kFT4SymbolSamples) { |
||||
addCoarseStart(start); |
||||
} |
||||
|
||||
const int nominalStart = maxStart / 2; |
||||
addCoarseStart(nominalStart - 2 * kFT4SymbolSamples); |
||||
addCoarseStart(nominalStart - kFT4SymbolSamples); |
||||
addCoarseStart(nominalStart); |
||||
addCoarseStart(nominalStart + kFT4SymbolSamples); |
||||
addCoarseStart(nominalStart + 2 * kFT4SymbolSamples); |
||||
addCoarseStart(maxStart); |
||||
|
||||
const int eighthSymbol = kFT4SymbolSamples / 8; |
||||
const std::array<int, 9> fineOffsets = {{ |
||||
-4 * eighthSymbol, |
||||
-3 * eighthSymbol, |
||||
-2 * eighthSymbol, |
||||
-eighthSymbol, |
||||
0, |
||||
eighthSymbol, |
||||
2 * eighthSymbol, |
||||
3 * eighthSymbol, |
||||
4 * eighthSymbol |
||||
}}; |
||||
|
||||
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 coarseStart : coarseStarts) |
||||
{ |
||||
for (int offset : fineOffsets) { |
||||
addStartCandidate(coarseStart + offset); |
||||
} |
||||
} |
||||
|
||||
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()) - 5); |
||||
|
||||
for (int toneBin = minToneBin; toneBin <= maxToneBin; toneBin++) |
||||
{ |
||||
float sync = 0.0f; |
||||
float noise = 0.0f; |
||||
collectSyncMetrics(frame.bins, toneBin, sync, noise); |
||||
|
||||
if (sync < 1.8f) { |
||||
continue; |
||||
} |
||||
|
||||
const float score = sync - 1.0f * (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(200, static_cast<int>(candidates.size())); |
||||
const int ldpcThreshold = std::max(25, m_params.osd_ldpc_thresh - 50); |
||||
|
||||
for (int candidateIndex = 0; candidateIndex < maxDecodeCandidates; candidateIndex++) |
||||
{ |
||||
const FT4Candidate& candidate = candidates[candidateIndex]; |
||||
const FT4Frame& frame = frames[candidate.frameIndex]; |
||||
const float refinedToneBin = refineToneBin(frame.bins, candidate.toneBin); |
||||
std::array<float, 174> llr; |
||||
buildBitMetrics(frame.bins, refinedToneBin, llr); |
||||
|
||||
int plain[174]; |
||||
int ldpcOk = 0; |
||||
int correct_bits = 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]; |
||||
|
||||
if (llr.data()[i] < 0 && a174[i] == 1) { |
||||
correct_bits += 1; |
||||
} else if (llr.data()[i] > 0 && a174[i] == 0) { |
||||
correct_bits += 1; |
||||
} |
||||
} |
||||
|
||||
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 tone0 = refinedToneBin * binSpacing; |
||||
|
||||
if (snr < -26.0f) { |
||||
continue; |
||||
} |
||||
|
||||
const float off = static_cast<float>(m_start) / m_rate + static_cast<float>(candidate.start) / m_rate; |
||||
m_cb->hcb(a91, tone0, off, "FT4-EXP", snr, 0, correct_bits); |
||||
} |
||||
} |
||||
|
||||
|
||||
} // namespace FT8
|
||||
@ -1,68 +0,0 @@
@@ -1,68 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2026 Edouard Griffiths, F4EXB <f4exb06@gmail.com> //
|
||||
// //
|
||||
// This is the code from ft8mon: https://github.com/rtmrtmrtmrtm/ft8mon //
|
||||
// reformatted and adapted to Qt and SDRangel context //
|
||||
// //
|
||||
// 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/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
#ifndef INCLUDE_FT4WORKER_H |
||||
#define INCLUDE_FT4WORKER_H |
||||
|
||||
#include <QObject> |
||||
#include <vector> |
||||
|
||||
#include "ft4.h" |
||||
|
||||
namespace FT8 { |
||||
|
||||
class CallbackInterface; |
||||
|
||||
class FT4Worker : public QObject |
||||
{ |
||||
Q_OBJECT |
||||
public: |
||||
FT4Worker( |
||||
const std::vector<float>& samples, |
||||
float minHz, |
||||
float maxHz, |
||||
int start, |
||||
int rate, |
||||
CallbackInterface *cb, |
||||
const FT4ParamsLight& params |
||||
); |
||||
|
||||
void start_work(); |
||||
|
||||
private: |
||||
static float binPowerInterpolated(const FFTEngine::ffts_t& bins, int symbolIndex, float toneBin); |
||||
void collectSyncMetrics(const FFTEngine::ffts_t& bins, float toneBin, float& sync, float& noise) const; |
||||
float refineToneBin(const FFTEngine::ffts_t& bins, int toneBin) const; |
||||
void buildBitMetrics(const FFTEngine::ffts_t& bins, float toneBin, std::array<float, 174>& bitMetrics) const; |
||||
FFTEngine::ffts_t makeFrameBins(int start); |
||||
void decode(); |
||||
|
||||
std::vector<float> m_samples; |
||||
float m_minHz; |
||||
float m_maxHz; |
||||
int m_start; |
||||
int m_rate; |
||||
CallbackInterface *m_cb; |
||||
FT4ParamsLight m_params; |
||||
FFTEngine m_fftEngine; |
||||
}; |
||||
|
||||
} // namespace FT8
|
||||
|
||||
#endif // INCLUDE_FT4WORKER_H
|
||||
Loading…
Reference in new issue