Browse Source

FT8 demod: removed experimental FT4 decoder

chirpmodem-v8.0.0
f4exb 9 months ago
parent
commit
26cfbac9b7
  1. 2
      ft8/CMakeLists.txt
  2. 95
      ft8/ft4.cpp
  3. 29
      ft8/ft4.h
  4. 436
      ft8/ft4worker.cpp
  5. 68
      ft8/ft4worker.h
  6. 121
      plugins/channelrx/demodft8/ft8demodworker.cpp
  7. 4
      plugins/channelrx/demodft8/ft8demodworker.h

2
ft8/CMakeLists.txt

@ -3,7 +3,6 @@ project(ft8) @@ -3,7 +3,6 @@ project(ft8)
set(ft8_SOURCES
arrays.cpp
fft.cpp
ft4worker.cpp
ft4.cpp
fftbuffers.cpp
ft8.cpp
@ -21,7 +20,6 @@ set(ft8_SOURCES @@ -21,7 +20,6 @@ set(ft8_SOURCES
set(ft8_HEADERS
arrays.h
fft.h
ft4worker.h
fftbuffers.h
ft8.h
ft8plan.h

95
ft8/ft4.cpp

@ -13,7 +13,6 @@ @@ -13,7 +13,6 @@
#include <QDebug>
#include "ft4.h"
#include "ft4worker.h"
#include "fft.h"
#include "osd.h"
#include "libldpc.h"
@ -3789,100 +3788,6 @@ std::vector<int> FT4::recode(int a174[]) @@ -3789,100 +3788,6 @@ std::vector<int> FT4::recode(int a174[])
return out103;
}
FT4DecoderLight::~FT4DecoderLight()
{
forceQuit();
}
void FT4DecoderLight::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 FT4DecoderLight::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::FT4DecoderLight::wait: thread timed out");
thread_timeout = 50;
}
threads.erase(threads.begin());
}
}
void FT4DecoderLight::forceQuit()
{
while (!threads.empty())
{
threads.front()->quit();
threads.front()->wait();
threads.erase(threads.begin());
}
}
FT4Decoder::~FT4Decoder()
{
forceQuit(); // stop all remaining running threads if any

29
ft8/ft4.h

@ -632,35 +632,6 @@ private: @@ -632,35 +632,6 @@ private:
}; // class FT4
class FT8_API FT4DecoderLight : public QObject
{
Q_OBJECT
public:
~FT4DecoderLight();
void 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,
struct cdecode *
);
void wait(double time_left);
void forceQuit();
FT4ParamsLight& getParams() { return params; }
private:
FT4ParamsLight params;
std::vector<QThread*> threads;
};
class FT8_API FT4Decoder : public QObject {
Q_OBJECT
public:

436
ft8/ft4worker.cpp

@ -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

68
ft8/ft4worker.h

@ -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

121
plugins/channelrx/demodft8/ft8demodworker.cpp

@ -38,123 +38,6 @@ @@ -38,123 +38,6 @@
#include "libldpc.h"
#include "osd.h"
namespace {
// 87 data symbols, 4 sync blocks of 4 symbols each, total 103 symbols per frame
constexpr int kFT4SymbolSamples = 576; // Number of samples per symbol at 12 kHz sample rate
constexpr int kFT4TotalSymbols = 103; // Number of symbols in a complete FT4 frame (including sync and data symbols and excluding the 2 ramp symbols)
constexpr int kFT4DataSymbols = 87; // Number of data symbols in a FT4 frame
constexpr int kFT4FrameSamples = kFT4TotalSymbols * kFT4SymbolSamples; // Total number of samples in a FT4 frame
const float kFT4ToneSpacing = FT8DemodSettings::m_ft8SampleRate / static_cast<float>(kFT4SymbolSamples); // Tone spacing in Hz
// Costas arrays for FT4 sync detection, indexed by block and symbol index within block
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 start;
float tone0;
float sync;
float noise;
float score;
};
float goertzelPower(const int16_t *samples, int sampleCount, float sampleRate, float frequency)
{
const float omega = 2.0f * static_cast<float>(M_PI) * frequency / sampleRate;
const float coeff = 2.0f * std::cos(omega);
float q0 = 0.0f;
float q1 = 0.0f;
float q2 = 0.0f;
for (int i = 0; i < sampleCount; i++)
{
q0 = coeff * q1 - q2 + (samples[i] / 32768.0f);
q2 = q1;
q1 = q0;
}
return q1 * q1 + q2 * q2 - coeff * q1 * q2;
}
float symbolTonePower(const int16_t *buffer, int start, int symbolIndex, float tone0, int tone)
{
const int symbolStart = start + symbolIndex * kFT4SymbolSamples;
const float frequency = tone0 + tone * kFT4ToneSpacing;
return goertzelPower(&buffer[symbolStart], kFT4SymbolSamples, FT8DemodSettings::m_ft8SampleRate, frequency);
}
void collectFT4SyncMetrics(const int16_t *buffer, int start, float tone0, float& sync, float& noise)
{
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 = symbolTonePower(buffer, start, symbolIndex, tone0, tone);
if (tone == expectedTone) {
sync += power;
} else {
noise += power;
}
}
}
}
}
void buildFT4BitMetrics(const int16_t *buffer, int start, float tone0, std::array<float, 174>& bitMetrics)
{
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] = symbolTonePower(buffer, start, symbolIndex, tone0, 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;
}
}
} // namespace
FT8DemodWorker::FT8Callback::FT8Callback(
const QDateTime& periodTS,
qint64 baseFrequency,
@ -300,7 +183,7 @@ void FT8DemodWorker::setDecoderMode(int decoderMode) @@ -300,7 +183,7 @@ void FT8DemodWorker::setDecoderMode(int decoderMode)
m_unsupportedModeWarningPending = true;
}
bool FT8DemodWorker::processFT4Experimental(int16_t *buffer, int frameSampleCount, FT8Callback& ft8Callback)
bool FT8DemodWorker::processFT4(int16_t *buffer, int frameSampleCount, FT8Callback& ft8Callback)
{
std::vector<float> samples(frameSampleCount);
std::transform(
@ -404,7 +287,7 @@ void FT8DemodWorker::processBuffer(int16_t *buffer, QDateTime periodTS) @@ -404,7 +287,7 @@ void FT8DemodWorker::processBuffer(int16_t *buffer, QDateTime periodTS)
}
else if (m_decoderMode == FT8DemodSettings::DecoderModeFT4)
{
const bool decoded = processFT4Experimental(buffer, frameSampleCount, ft8Callback);
const bool decoded = processFT4(buffer, frameSampleCount, ft8Callback);
if (!decoded && m_unsupportedModeWarningPending)
{

4
plugins/channelrx/demodft8/ft8demodworker.h

@ -92,7 +92,7 @@ private: @@ -92,7 +92,7 @@ private:
const QSet<QString> *m_validCallsigns;
};
bool processFT4Experimental(int16_t *buffer, int frameSampleCount, FT8Callback& ft8Callback);
bool processFT4(int16_t *buffer, int frameSampleCount, FT8Callback& ft8Callback);
QString m_samplesPath;
QString m_logsPath;
@ -112,7 +112,7 @@ private: @@ -112,7 +112,7 @@ private:
bool m_invalidSequence;
qint64 m_baseFrequency;
FT8::FT8Decoder m_ft8Decoder;
FT8::FT4DecoderLight m_ft4Decoder;
FT8::FT4Decoder m_ft4Decoder;
FT8::Packing m_packing;
MessageQueue *m_guiReportingMessageQueue;
MessageQueue *m_pskReportingMessageQueue;

Loading…
Cancel
Save