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.
 
 
 
 
 
 

846 lines
26 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 <chrono>
#include <cmath>
#include <exception>
#include "util/profiler.h"
#include "dvbsreceiver.h"
#include "samplethread.h"
namespace dvbs {
// e^j(angle): for the small angles a loop turns by, sine and cosine to the fifth and fourth power (to 1e-6 within 0.3
// radians, and the rotator's renormalised each group), else exactly
inline std::complex<float> QPSKCarrier::rotation(double angle)
{
if (std::fabs(angle) > 0.3) {
return std::complex<float>((float) std::cos(angle), (float) std::sin(angle));
}
const float x = (float) angle, x2 = x * x;
return std::complex<float>(1.0f - x2 * (0.5f - x2 * (1.0f / 24.0f)), x * (1.0f - x2 * ((1.0f / 6.0f) - x2 * (1.0f / 120.0f))));
}
double Receiver::now()
{
return std::chrono::duration<double>(std::chrono::steady_clock::now().time_since_epoch()).count();
}
QPSKCarrier::QPSKCarrier() :
m_tracking(false),
m_rotator(1.0f, 0.0f),
m_frequency(0.0),
m_kp(0.0),
m_ki(0.0),
m_bandwidth(m_trackBandwidth),
m_lock(0.0),
m_errorPower(1.0),
m_averaged(false),
m_m2(0.0),
m_m4(0.0),
m_tracked(0),
m_unlocked(0),
m_acquisitions(0)
{
reset();
}
void QPSKCarrier::reset()
{
m_tracking = false;
m_acquire.clear();
m_acquire.reserve(m_acquireSymbols);
m_rotator = Cf(1.0f, 0.0f);
m_frequency = 0.0;
m_pendingShift = 0.0;
m_pendingSymbols = 0;
m_lock = 0.0;
m_errorPower = 1.0;
m_averaged = false;
m_m2 = 0.0;
m_m4 = 0.0;
m_tracked = 0;
m_unlocked = 0;
}
void QPSKCarrier::shiftFrequency(double cyclesPerSymbol, int afterSymbols)
{
if (afterSymbols <= 0)
{
m_frequency -= cyclesPerSymbol;
}
else
{
m_pendingShift += cyclesPerSymbol;
m_pendingSymbols = afterSymbols;
}
}
void QPSKCarrier::setBandwidth(double bnT)
{
if (bnT != m_bandwidth)
{
m_bandwidth = bnT;
if (m_tracking && (m_tracked >= m_acquireTrackSymbols)) {
computeGains(bnT);
}
}
}
void QPSKCarrier::computeGains(double bnT)
{
// Phase detector Im(w conj(d)) for unit power symbols: sin of the error, so a gain of 1 (cycles: 2 pi)
const double zeta = 0.707;
const double theta = bnT / (zeta + 1.0 / (4.0 * zeta));
const double d = 1.0 + 2.0 * zeta * theta + theta * theta;
m_kp = 4.0 * zeta * theta / d / (2.0 * m_pi);
m_ki = 4.0 * theta * theta / d / (2.0 * m_pi);
}
int QPSKCarrier::process(const Cf *z, int nbSymbols, Cf *w, bool& restarted, int& restartAt)
{
static const float a = 0.70710678f;
static const int group = 8;
int i = 0, out = 0;
while (i < nbSymbols)
{
if (!m_tracking)
{
for (; (i < nbSymbols) && ((int) m_acquire.size() < m_acquireSymbols); i++)
{
const std::complex<double> zd(z[i].real(), z[i].imag());
const std::complex<double> z2 = zd * zd;
m_acquire.push_back(z2 * z2);
}
if ((int) m_acquire.size() < m_acquireSymbols) {
break;
}
// The fourth power's line, at 4 times the offset
fft(m_acquire);
m_frequency = peakFrequency(m_acquire) / 4.0;
m_pendingShift = 0.0;
m_pendingSymbols = 0;
m_acquire.clear();
m_rotator = Cf(1.0f, 0.0f);
m_tracking = true;
m_tracked = 0;
m_unlocked = 0;
m_lock = 0.0;
m_errorPower = 1.0;
m_averaged = false;
m_m2 = 0.0;
m_m4 = 0.0;
m_acquisitions++;
computeGains(m_acquireBandwidth);
continue;
}
const int first = i;
double lockNumerator = 0.0, lockDenominator = 0.0, errorPower = 0.0, powerSum = 0.0;
for (int n = 0; (i < nbSymbols) && m_tracking; i += n)
{
// A group ends where a shift of the frequency is due
n = std::min(m_pendingSymbols > 0 ? std::min(group, m_pendingSymbols) : group, nbSymbols - i);
// This group turned at the loop's frequency from the rotator
const Cf step = rotation(-2.0 * m_pi * m_frequency);
Cf rot = m_rotator;
float error = 0.0f, num = 0.0f, den = 0.0f, err = 0.0f, pw = 0.0f;
float rr = rot.real(), ri = rot.imag();
const float sr = step.real(), si = step.imag();
for (int k = 0; k < n; k++)
{
const float zr = z[i + k].real(), zi = z[i + k].imag();
const Cf v(zr * rr - zi * ri, zr * ri + zi * rr);
const float t = rr * sr - ri * si;
ri = rr * si + ri * sr;
rr = t;
w[out + k] = v;
const float dr = withSignOf(a, v.real()), di = withSignOf(a, v.imag());
error += v.imag() * dr - v.real() * di; // Im(v conj(d)): the sine of the error, at unit power
const float er = v.real() - dr, ei = v.imag() - di;
err += er * er + ei * ei;
const float p = v.real() * v.real() + v.imag() * v.imag();
const float re2 = v.real() * v.real() - v.imag() * v.imag(), im2 = 2.0f * v.real() * v.imag();
num -= re2 * re2 - im2 * im2; // -Re(v^4): QPSK's points' fourth power is -1
den += p * p;
pw += p;
}
out += n;
lockNumerator += num;
lockDenominator += den;
powerSum += pw;
errorPower += err;
// The loop, as a symbol by symbol one would have moved over the group
m_frequency += m_ki * error;
const double turn = -2.0 * m_pi * m_kp * error;
rot = Cf(rr, ri);
m_rotator = rot * rotation(turn);
// Back to unit magnitude, by a Newton step for 1 / sqrt (it drifts by rounding only)
m_rotator *= 1.5f - 0.5f * std::norm(m_rotator);
const uint64_t before = m_tracked;
m_tracked += n;
if ((m_pendingSymbols > 0) && ((m_pendingSymbols -= n) == 0))
{
m_frequency -= m_pendingShift;
m_pendingShift = 0.0;
}
if ((before < m_acquireTrackSymbols) && (m_tracked >= m_acquireTrackSymbols)) {
computeGains(m_bandwidth);
}
}
// Lock (the fourth power's coherence) and error power, averaged over a couple of thousand symbols
const int count = i - first;
if ((count > 0) && (lockDenominator > 0.0))
{
const double weight = std::min(1.0, count / 2048.0);
m_lock += (lockNumerator / lockDenominator - m_lock) * weight;
// The first update whole (from 0, the moments' SNR would read noise alone until they'd averaged up)
const double average = m_averaged ? std::min(1.0, count / 4096.0) : 1.0;
m_errorPower += (errorPower / count - m_errorPower) * average;
m_m2 += (powerSum / count - m_m2) * average;
m_m4 += (lockDenominator / count - m_m4) * average;
m_averaged = true;
}
// Unlocked for a while: acquire again
if ((m_tracked > (uint64_t) m_acquireSymbols) && (m_lock < m_lockThreshold / 2.0))
{
m_unlocked += count;
if (m_unlocked > m_unlockedLimit)
{
m_tracking = false;
restarted = true;
restartAt = out;
}
}
else
{
m_unlocked = 0;
}
}
return out;
}
double QPSKCarrier::mer() const
{
return -10.0 * std::log10(std::max(1e-10, m_errorPower));
}
// For a constant envelope (QPSK) in complex Gaussian noise, E|y|^2 = S + N and E|y|^4 = S^2 + 4SN + 2N^2, so
// S = sqrt(2 M2^2 - M4) and N = M2 - S
double QPSKCarrier::snr() const
{
const double s2 = 2.0 * m_m2 * m_m2 - m_m4;
if ((m_m2 <= 0.0) || (s2 <= 0.0)) {
return -10.0; // Noise alone, as far as can be told
}
const double s = std::sqrt(s2);
const double n = m_m2 - s;
return n > 0.0 ? std::min(50.0, 10.0 * std::log10(s / n)) : 50.0;
}
Receiver::Receiver(bool threaded) :
m_threaded(threaded),
m_inputRate(2e6),
m_symbolRate(1e6),
m_codeRate(-1),
m_carrierBandwidth(0.0),
m_fecLocked(false),
m_displayRequested(true),
m_displayMaxSymbols(2000),
m_displayPoints(512),
m_busy(false),
m_stop(false),
m_resetEpoch(0),
m_unlockedSymbols(0),
m_fecProgress(false),
m_lastGoodPackets(0),
m_restarts(0),
m_decodeEpoch(0),
m_fecCodeRate(-1),
m_queueWaits(0),
m_fecSeconds(0.0)
{
m_fe = &m_frontEnd;
m_frontEndRestart = false;
m_fec.setPacketCallback([this](const uint8_t *packet) {
m_fecPackets.insert(m_fecPackets.end(), packet, packet + dvbt::tsPacketSize);
});
m_frontEnd.configure(m_inputRate, m_symbolRate, 0.35);
m_fec.setSymbolRate(m_symbolRate);
m_frontEnd.setTimingBandwidth(m_timingAcquire);
m_recentSymbols.assign(m_nbDisplaySymbols, Cf(0.0f, 0.0f));
if (m_threaded)
{
m_fecThread = std::thread(&Receiver::runFEC, this);
m_demodThread.reset(new SampleThread([this](const Cf *samples, int nbSamples) {
demodulate(samples, nbSamples);
}));
}
}
Receiver::~Receiver()
{
m_demodThread.reset();
if (m_threaded)
{
{
std::lock_guard<std::mutex> lock(m_mutex);
m_stop = true;
}
m_available.notify_all();
m_space.notify_all();
m_fecThread.join();
}
}
void Receiver::configure(double inputRate, double symbolRate)
{
if (m_demodThread) {
m_demodThread->discard();
}
m_inputRate = inputRate;
m_symbolRate = symbolRate;
m_frontEnd.configure(inputRate, symbolRate, 0.35);
m_fec.setSymbolRate(symbolRate);
reset();
}
void Receiver::setSharedFrontEnd(FrontEnd *frontEnd)
{
m_fe = frontEnd ? frontEnd : &m_frontEnd;
m_frontEndRestart = false;
}
void Receiver::reset()
{
if (m_demodThread) {
m_demodThread->discard();
}
// A shared front end's reset by its owner
if (m_fe == &m_frontEnd)
{
m_frontEnd.reset();
m_frontEnd.setTimingBandwidth(m_timingAcquire);
}
m_frontEndRestart = false;
m_carrier.reset();
m_fecLocked = false;
m_unlockedSymbols = 0;
m_fecProgress = false;
{
std::lock_guard<std::mutex> lock(m_demodMutex);
m_demodStatus = Status();
m_demodStatus.m_symbolRate = m_symbolRate;
m_displaySymbols.clear();
std::fill(m_recentSymbols.begin(), m_recentSymbols.end(), Cf(0.0f, 0.0f));
}
if (m_threaded)
{
std::lock_guard<std::mutex> lock(m_mutex);
while (!m_queue.empty())
{
if (!m_queue.front().m_reset && (m_free.size() < m_maxQueued + 2))
{
m_queue.front().m_soft.clear();
m_free.push_back(std::move(m_queue.front()));
}
m_queue.pop_front();
}
SoftBlock block;
block.m_reset = true;
block.m_epoch = ++m_resetEpoch;
m_queue.push_back(std::move(block));
m_packets.clear();
// Again with the new epoch: the error correction thread may have published a block's lock since. The status
// is the last block's until the reset's decoded: not its lock
m_fecLocked = false;
m_fecProgress = false;
m_fecStatus.m_state = FECDecoder::State::Searching;
m_fecStatus.m_tsSync = false;
m_space.notify_all();
m_available.notify_one();
}
else
{
m_fec.reset();
m_fecPackets.clear();
std::lock_guard<std::mutex> lock(m_mutex);
m_packets.clear();
m_fecStatus = m_fec.getStatus();
}
}
void Receiver::process(const Cf *samples, int nbSamples)
{
if (m_demodThread) {
m_demodThread->push(samples, nbSamples);
} else {
demodulate(samples, nbSamples);
}
deliverPackets();
}
void Receiver::demodulate(const Cf *samples, int nbSamples)
{
const double start = now();
m_symbols.clear();
m_frontEnd.process(samples, nbSamples, m_symbols);
demodulateSymbols(start, now());
}
void Receiver::processSymbols(const Cf *symbols, int nbSymbols)
{
const double start = now();
m_symbols.assign(symbols, symbols + nbSymbols);
demodulateSymbols(start, start);
}
// The error correction's sync (Viterbi, deinterleaver, packets) would be lost in the gap, its packets failing RS until
// it found it was: it searches again from the symbols after (the carrier loop keeps its frequency, and follows the
// phase again). As after a restart, the packets aren't dropped: the transport stream goes on after the gap
void Receiver::discontinuity()
{
deliverReset();
}
void Receiver::frontEndShifted(double hz, int afterSymbols)
{
// Acquiring, the frequency's measured afresh
if (m_carrier.tracking() && (m_symbolRate > 0.0)) {
m_carrier.shiftFrequency(hz / m_symbolRate, afterSymbols);
}
}
// As a restart of this receiver's own, without asking for the front end's: the carrier acquired again from the symbols
// after, and the error correction searching again
void Receiver::frontEndReset()
{
m_carrier.reset();
m_unlockedSymbols = 0;
deliverReset();
}
void Receiver::demodulateSymbols(double start, double frontEndEnd)
{
const double bandwidth = m_carrierBandwidth;
if (bandwidth > 0.0)
{
m_carrier.setBandwidth(bandwidth);
}
else if (m_carrier.tracking())
{
// Narrow at low SNR, where a wide loop slips, wide at high SNR, to follow phase noise
const double mer = m_carrier.mer();
m_carrier.setBandwidth(std::max(0.005, std::min(0.02, 0.005 + (mer - 5.0) * 0.0025)));
}
SoftBlock& block = m_filling;
block.m_reset = false;
bool restart = false;
int restartAt = 0;
m_tracked.resize(m_symbols.size());
const int n = m_carrier.process(m_symbols.data(), (int) m_symbols.size(), m_tracked.data(), restart, restartAt);
block.m_soft.resize(2 * n);
softBits(m_tracked.data(), n, m_softScale, block.m_soft.data());
// The last symbols, for display
if (n > 0)
{
const int keep = std::min(n, (int) m_recentSymbols.size());
m_recentSymbols.erase(m_recentSymbols.begin(), m_recentSymbols.begin() + keep);
m_recentSymbols.insert(m_recentSymbols.end(), m_tracked.begin() + (n - keep), m_tracked.begin() + n);
}
// A large frequency offset is moved to the front end's NCO, so the matched filter stays centred on the signal (only
// when tracking: an unlocked loop's frequency is nothing to move, and would mix two into the next acquisition's).
// A shared front end's only with the FEC locked: the carrier loop can track a DVB-S2 signal for a while, and move
// it from under the DVB-S2 receiver searching
if (m_carrier.tracking() && ((m_fe == &m_frontEnd) || m_fecLocked) && (std::fabs(m_carrier.frequency()) > m_foldBack))
{
const double f = m_carrier.frequency();
const int held = m_fe->heldSymbols();
m_fe->adjustFrequency(f * m_symbolRate);
m_carrier.shiftFrequency(f, held);
}
// No packet through RS for a while: the carrier may have been found wrong, a quarter of the symbol rate out (as QPSK
// turned 90 degrees a symbol looks right to the carrier loop, and the code search can even find sync bytes now and
// then), from a spectrum measured as the signal changed, so it's measured again
if (m_fecProgress.exchange(false) || m_fe->getStatus().m_estimating)
{
m_unlockedSymbols = 0;
}
else if ((m_unlockedSymbols += m_symbols.size()) > std::max(m_relockSeconds * m_symbolRate, m_relockMinSymbols))
{
// A shared front end's restarted by its owner, if the DVB-S2 receiver hasn't a lock it'd lose
if (m_fe == &m_frontEnd)
{
m_frontEnd.reset();
m_frontEnd.setTimingBandwidth(m_timingAcquire);
}
else
{
m_frontEndRestart = true;
}
m_carrier.reset();
m_unlockedSymbols = 0;
m_restarts++;
restart = true;
restartAt = n; // This block's symbols are the lock's before: before the reset
}
// A shared one's owner sets them, from both receivers, after each block
if (m_fe == &m_frontEnd)
{
m_frontEnd.setTimingBandwidth(m_fecLocked ? m_timingTrack : m_timingAcquire);
m_frontEnd.setEqualiserReference(m_fecLocked, frontEndEsN0());
}
const double end = now();
{
std::lock_guard<std::mutex> lock(m_demodMutex);
Status& s = m_demodStatus;
s.m_frontEnd = m_fe->getStatus();
s.m_symbolRate = m_symbolRate;
s.m_carrierLocked = m_carrier.locked();
s.m_carrierLock = m_carrier.lockMetric();
s.m_mer = m_carrier.tracking() ? m_carrier.mer() : 0.0;
s.m_snr = m_carrier.tracking() ? m_carrier.snr() : 0.0;
s.m_carrierAcquisitions = m_carrier.acquisitions();
s.m_restarts = m_restarts;
s.m_frequencyOffset = s.m_frontEnd.m_frequencyOffset + (m_carrier.tracking() ? m_carrier.frequency() * m_symbolRate : 0.0);
s.m_clockOffset = s.m_frontEnd.m_clockOffset;
s.m_seconds[0] += frontEndEnd - start;
s.m_seconds[1] += end - frontEndEnd;
if (m_displayRequested)
{
const int count = std::min(m_displayMaxSymbols, (int) m_recentSymbols.size());
m_displaySymbols.assign(m_recentSymbols.end() - count, m_recentSymbols.end());
m_fe->getSpectrum(m_displaySpectrum, m_displayPoints);
m_displayRequested = false;
}
}
// After a restart, the symbols of the lock before it go to the error correction first, then the reset
if (restart)
{
if (restartAt > 0)
{
SoftBlock before;
before.m_soft.assign(block.m_soft.begin(), block.m_soft.begin() + 2 * restartAt);
block.m_soft.erase(block.m_soft.begin(), block.m_soft.begin() + 2 * restartAt);
deliver(before);
}
deliverReset();
}
deliver(block);
}
void Receiver::deliverReset()
{
SoftBlock resetBlock;
resetBlock.m_reset = true;
if (m_threaded)
{
std::unique_lock<std::mutex> lock(m_mutex);
resetBlock.m_epoch = m_resetEpoch; // Not a reset of the receiver: packets are still wanted
m_queue.push_back(std::move(resetBlock));
m_available.notify_one();
}
else
{
resetBlock.m_epoch = m_resetEpoch;
decodeBlock(resetBlock);
}
}
void Receiver::deliver(SoftBlock& block)
{
if (block.m_soft.empty()) {
return;
}
if (!m_threaded)
{
decodeBlock(block);
std::lock_guard<std::mutex> lock(m_mutex);
m_packets.insert(m_packets.end(), m_fecPackets.begin(), m_fecPackets.end());
m_fecPackets.clear();
return;
}
std::unique_lock<std::mutex> lock(m_mutex);
if (m_queue.size() >= m_maxQueued)
{
m_queueWaits++;
PROFILER_START()
m_space.wait(lock, [this]() { return m_stop || (m_queue.size() < m_maxQueued); });
PROFILER_STOP("DVB-S waiting for its FEC thread")
}
SoftBlock queued;
if (!m_free.empty())
{
queued = std::move(m_free.back());
m_free.pop_back();
}
queued.m_reset = false;
queued.m_soft.swap(block.m_soft);
m_queue.push_back(std::move(queued));
m_available.notify_one();
}
// In the error correction thread (or the caller's, unthreaded). Returns whether packets passed RS
bool Receiver::decodeBlock(SoftBlock& block)
{
const int rate = m_codeRate;
if (rate != m_fecCodeRate)
{
m_fecCodeRate = rate;
m_fec.setCodeRate(rate);
}
const double start = now();
if (block.m_reset) {
m_fec.reset();
} else {
m_fec.decode(block.m_soft.data(), (int) block.m_soft.size() / 2);
}
m_fecSeconds = m_fecSeconds + (now() - start); // Only this thread writes it
PROFILER_ADD("DVB-S FEC thread (search and decoding)", (qint64) ((now() - start) * 1e9))
const FECDecoder::Status& fecStatus = m_fec.getStatus();
// RS failures include packets dropped before the outer decoder's synchronised, not counted as packets
const uint64_t good = fecStatus.m_outer.m_packets - std::min(fecStatus.m_outer.m_packets, fecStatus.m_outer.m_rsFailed);
// Packets through RS with the transport stream in sync: a false lock's garbage may now and then pass RS
const bool progress = (good > m_lastGoodPackets) && fecStatus.m_tsSync;
m_lastGoodPackets = good;
// Threaded, runFEC() publishes them, if the block's not from before a reset
if (!m_threaded)
{
m_fecLocked = fecStatus.m_state == FECDecoder::State::Locked;
if (progress) {
m_fecProgress = true;
}
std::lock_guard<std::mutex> lock(m_mutex); // getStatus() may be called from another thread
m_fecStatus = fecStatus;
}
return progress;
}
void Receiver::runFEC()
{
std::unique_lock<std::mutex> lock(m_mutex);
while (true)
{
m_available.wait(lock, [this]() { return m_stop || !m_queue.empty(); });
if (m_stop) {
break;
}
SoftBlock block = std::move(m_queue.front());
m_queue.pop_front();
m_busy = true;
lock.unlock();
m_space.notify_one();
bool progress = false;
// An exception (out of memory) loses the block, the decoder searching again, rather than ending the process
try {
progress = decodeBlock(block);
} catch (const std::exception&) {
m_fec.reset();
}
const FECDecoder::Status status = m_fec.getStatus();
lock.lock();
if (block.m_reset && (block.m_epoch == m_resetEpoch)) {
m_decodeEpoch = block.m_epoch;
}
// A block of the signal before a reset of the receiver: its lock and progress aren't this one's. Published with
// the epoch checked under the lock, so reset() can't be followed by an old block's lock
const bool current = m_decodeEpoch == m_resetEpoch;
m_fecLocked = current && (status.m_state == FECDecoder::State::Locked);
if (current && progress) {
m_fecProgress = true;
}
// Packets from before a reset aren't wanted
if (!m_fecPackets.empty())
{
if (m_decodeEpoch == m_resetEpoch) {
m_packets.insert(m_packets.end(), m_fecPackets.begin(), m_fecPackets.end());
}
m_fecPackets.clear();
}
if (m_decodeEpoch == m_resetEpoch) {
m_fecStatus = status;
}
// Blocks are reused for their buffers: not reset blocks, which have none (one is queued at each restart, many
// a second without a signal), and no more than can be queued
if (!block.m_reset && (m_free.size() < m_maxQueued + 2))
{
block.m_soft.clear();
m_free.push_back(std::move(block));
}
m_busy = false;
if (idle()) {
m_idle.notify_all();
}
}
}
// With m_mutex locked
bool Receiver::idle() const
{
return m_queue.empty() && !m_busy;
}
void Receiver::deliverPackets()
{
{
std::lock_guard<std::mutex> lock(m_mutex);
m_delivering.swap(m_packets);
}
if (m_packetCallback)
{
for (size_t i = 0; i + dvbt::tsPacketSize <= m_delivering.size(); i += dvbt::tsPacketSize) {
m_packetCallback(&m_delivering[i]);
}
}
m_delivering.clear();
}
void Receiver::flush()
{
if (m_demodThread) {
m_demodThread->drain();
}
if (m_threaded)
{
std::unique_lock<std::mutex> lock(m_mutex);
m_idle.wait(lock, [this] { return idle(); });
}
deliverPackets();
}
Receiver::Status Receiver::getStatus() const
{
Status status;
{
std::lock_guard<std::mutex> lock(m_demodMutex);
status = m_demodStatus;
}
{
std::lock_guard<std::mutex> lock(m_mutex);
status.m_fec = m_fecStatus;
status.m_queueWaits = m_queueWaits;
status.m_seconds[2] = m_fecSeconds;
}
if (status.m_frontEnd.m_estimating) {
status.m_state = State::Spectrum;
} else if (!status.m_carrierLocked && (status.m_fec.m_state != FECDecoder::State::Locked)) {
status.m_state = State::Carrier;
} else if (status.m_fec.m_state != FECDecoder::State::Locked) {
status.m_state = State::Code;
} else if (!status.m_fec.m_tsSync) {
status.m_state = State::Sync;
} else {
status.m_state = State::Locked;
}
return status;
}
void Receiver::getDisplayData(std::vector<Cf>& symbols, int maxSymbols, std::vector<float>& spectrumDb, int points) const
{
std::lock_guard<std::mutex> lock(m_demodMutex);
symbols = m_displaySymbols;
spectrumDb = m_displaySpectrum;
m_displayMaxSymbols = std::min(maxSymbols, m_nbDisplaySymbols);
m_displayPoints = points;
m_displayRequested = true;
}
} // namespace dvbs