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.
1252 lines
41 KiB
1252 lines
41 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 <cstring> |
|
#include <QDebug> |
|
|
|
#include "util/profiler.h" |
|
#include "dvbs2receiver.h" |
|
#include "samplethread.h" |
|
|
|
namespace dvbs2 { |
|
|
|
double Receiver::now() |
|
{ |
|
return std::chrono::duration<double>(std::chrono::steady_clock::now().time_since_epoch()).count(); |
|
} |
|
|
|
double Receiver::rollOffValue(int ro) |
|
{ |
|
// 3 (RO 11) isn't asked for: it marks the low roll-offs, which alternate with it as 4 to 6 |
|
static const double values[7] = {0.35, 0.25, 0.20, 0.35, 0.15, 0.10, 0.05}; |
|
return (ro >= 0) && (ro < 7) ? values[ro] : 0.35; |
|
} |
|
|
|
Receiver::Receiver(bool threaded, int decoderThreads) : |
|
m_threaded(threaded), |
|
m_inputRate(2e6), |
|
m_symbolRate(1e6), |
|
m_rollOffSetting(0.0), |
|
m_isiSetting(-1), |
|
m_maxIterations(m_defaultMaxIterations), |
|
m_matypeRollOff(-1), |
|
m_lowRollOffs(false), |
|
m_sinceLowRollOffs(0), |
|
m_unlockedSymbols(0), |
|
m_failedFrames(0), |
|
m_failingSymbols(0), |
|
m_restarts(0), |
|
m_displayRequested(true), |
|
m_displayMaxCells(2000), |
|
m_displayPoints(512), |
|
m_busy(false), |
|
m_stop(false), |
|
m_draining(false), |
|
m_resetEpoch(0), |
|
m_decodeEpoch(0), |
|
m_isi(-1), |
|
m_isisSeen(256, false), |
|
m_isisNullOnly(256, false), |
|
m_streamPackets(0), |
|
m_isiPackets(0), |
|
m_isiNulls(0), |
|
m_isiMissing(0), |
|
m_queueWaits(0) |
|
{ |
|
const int cores = std::max(1, (int) std::thread::hardware_concurrency()); |
|
const int threads = decoderThreads > 0 ? decoderThreads : std::max(1, std::min(4, cores - 2)); |
|
m_pool.reset(new dvbt2::LDPCPool(threads - 1)); |
|
// Whole rounds of the decoders (the pool's threads and the FEC thread's), a few batches at least |
|
m_takeBatches = (size_t) threads * std::max<size_t>(1, m_minTakeBatches / (size_t) threads); |
|
m_fe = &m_frontEnd; |
|
m_frontEndRestart = false; |
|
m_plLocked = false; |
|
m_frontEnd.configure(m_inputRate, m_symbolRate, 0.35); |
|
m_frontEnd.setTimingBandwidth(m_timingAcquire); |
|
m_bbDecoder.setHighEfficiencyAllowed(false); |
|
m_bbDecoder.setPacketCallback([this](const uint8_t *packet) { |
|
m_bbPackets.insert(m_bbPackets.end(), packet, packet + 188); |
|
m_streamPackets++; |
|
m_isiPackets++; |
|
m_isiNulls += (((packet[1] & 0x1f) << 8) | packet[2]) == 0x1fff; |
|
}); |
|
m_pl.setFrameCallback([this](XFECFrame& frame) { onFrame(frame); }); |
|
|
|
// As many as can be in use, so none's made as frames come (with the mutex the FEC thread wants): queued, taken to |
|
// decode, and resets. Their buffers grow as they're used |
|
const size_t nbSlots = m_maxQueued + m_takeBatches * m_maxLanes + 8; |
|
m_slots.reserve(2 * nbSlots); |
|
m_free.reserve(2 * nbSlots); |
|
|
|
for (size_t i = 0; i < nbSlots; i++) |
|
{ |
|
m_slots.emplace_back(new FrameSlot()); |
|
m_free.push_back(m_slots.back().get()); |
|
} |
|
|
|
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, m_rollOffSetting > 0.0 ? (double) m_rollOffSetting : 0.35); |
|
reset(); |
|
} |
|
|
|
void Receiver::setScramblingCode(int n) |
|
{ |
|
if (m_demodThread) { |
|
m_demodThread->discard(); |
|
} |
|
|
|
m_pl.setScramblingCode(n); |
|
reset(); |
|
} |
|
|
|
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_plLocked = false; |
|
m_awaitCorrection = 0; |
|
m_awaitClock = 0; |
|
m_pendingCorrection = 0.0; |
|
m_pl.reset(); |
|
m_unlockedSymbols = 0; |
|
m_failedFrames = 0; |
|
m_failingSymbols = 0; |
|
m_searchSeconds = 0.0; |
|
m_searchSymbols = 0; |
|
m_skipSymbols = 0; |
|
// Of the signal before (as after a retune): the matched filter's back to 0.35 until a BBHEADER. The low roll-offs' |
|
// tracking is the FEC thread's, reset where it reaches the reset (or below, unthreaded) |
|
m_matypeRollOff = -1; |
|
|
|
{ |
|
std::lock_guard<std::mutex> lock(m_demodMutex); |
|
m_demodStatus = Status(); |
|
m_demodStatus.m_symbolRate = m_symbolRate; |
|
m_displayCells.clear(); |
|
} |
|
|
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
|
|
while (!m_queue.empty()) |
|
{ |
|
m_free.push_back(m_queue.front()); |
|
m_queue.pop_front(); |
|
} |
|
|
|
m_packets.clear(); |
|
FrameSlot *slot = freeSlot(); |
|
slot->m_reset = true; |
|
slot->m_epoch = ++m_resetEpoch; |
|
|
|
if (m_threaded) |
|
{ |
|
m_queue.push_back(slot); |
|
m_space.notify_all(); |
|
m_available.notify_one(); |
|
} |
|
else |
|
{ |
|
m_free.push_back(slot); |
|
m_bbDecoder.reset(); |
|
clearStreams(); |
|
m_lowRollOffs = false; |
|
m_sinceLowRollOffs = 0; |
|
m_fecStatus = Status(); |
|
m_decodeEpoch = m_resetEpoch; |
|
} |
|
} |
|
|
|
void Receiver::discontinuity() |
|
{ |
|
// The search's budget skip goes on: cancelled at each drop (when behind, searching), the search ran at full |
|
// cost, so fell behind again, dropped again, and never kept to its budget |
|
m_pl.discontinuity(); |
|
} |
|
|
|
// The spectrum measured again: a shared front end's by its owner, if the DVB-S receiver hasn't a lock it'd lose |
|
void Receiver::restartFrontEnd() |
|
{ |
|
if (m_fe == &m_frontEnd) |
|
{ |
|
m_frontEnd.reset(); |
|
m_frontEnd.setTimingBandwidth(m_timingAcquire); |
|
} |
|
else |
|
{ |
|
m_frontEndRestart = true; |
|
} |
|
} |
|
|
|
// With m_mutex |
|
Receiver::FrameSlot *Receiver::freeSlot() |
|
{ |
|
if (m_free.empty()) |
|
{ |
|
m_slots.emplace_back(new FrameSlot()); |
|
return m_slots.back().get(); |
|
} |
|
|
|
FrameSlot *slot = m_free.back(); |
|
m_free.pop_back(); |
|
slot->m_reset = false; |
|
slot->m_skip = false; |
|
return slot; |
|
} |
|
|
|
void Receiver::process(const Cf *samples, int nbSamples) |
|
{ |
|
if (m_demodThread) { |
|
m_demodThread->push(samples, nbSamples); |
|
} else { |
|
demodulate(samples, nbSamples); |
|
} |
|
|
|
deliverPackets(); |
|
} |
|
|
|
void Receiver::setSharedFrontEnd(dvbs::FrontEnd *frontEnd) |
|
{ |
|
m_fe = frontEnd ? frontEnd : &m_frontEnd; |
|
m_frontEndRestart = false; |
|
} |
|
|
|
void Receiver::demodulate(const Cf *samples, int nbSamples) |
|
{ |
|
const double start = now(); |
|
m_symbols.clear(); |
|
m_frontEnd.process(samples, nbSamples, m_symbols); |
|
const double mid = now(); |
|
|
|
// Its own front end's load, for the search's budget |
|
if ((nbSamples > 0) && (m_inputRate > 0.0)) { |
|
m_otherLoad += 0.05 * ((mid - start) * m_inputRate / nbSamples - m_otherLoad); |
|
} |
|
|
|
demodulateSymbols(start, mid); |
|
} |
|
|
|
void Receiver::processSymbols(const Cf *symbols, int nbSymbols, uint64_t first, const dvbs::FrontEnd::Status& frontEnd, |
|
uint64_t corrections, uint64_t boundary, double otherLoad) |
|
{ |
|
const double start = now(); |
|
m_feStatus = frontEnd; |
|
m_otherLoad = otherLoad; |
|
|
|
// A clock correction asked for, made before this block's symbols |
|
if ((m_awaitClock != 0) && (frontEnd.m_clockAdjustments >= m_awaitClock)) |
|
{ |
|
m_awaitClock = 0; |
|
m_pl.clockCorrected(); |
|
} |
|
|
|
if (m_awaitCorrection == 0) |
|
{ |
|
m_symbols.assign(symbols, symbols + nbSymbols); |
|
demodulateSymbols(start, start); |
|
return; |
|
} |
|
|
|
// A frequency correction asked of the front end: the symbols it made before making it (more than when it was in |
|
// this thread: those queued for this one), and those it held then, are at the frequency before, so they're turned |
|
// here as it now turns those after. Skipped, as many packets were lost as symbols were queued |
|
const int before = corrections >= m_awaitCorrection |
|
? (int) std::min<uint64_t>((uint64_t) nbSymbols, boundary > first ? boundary - first : 0) : nbSymbols; |
|
|
|
if (before > 0) |
|
{ |
|
m_symbols.assign(symbols, symbols + before); |
|
const double step = -2.0 * 3.141592653589793 * m_pendingCorrection; |
|
const Cf stepRot((float) std::cos(step), (float) std::sin(step)); |
|
Cf rot((float) std::cos(m_pendingPhase), (float) std::sin(m_pendingPhase)); |
|
|
|
for (Cf& s : m_symbols) |
|
{ |
|
s *= rot; |
|
rot *= stepRot; |
|
} |
|
|
|
m_pendingPhase = std::remainder(m_pendingPhase + before * step, 2.0 * 3.141592653589793); |
|
demodulateSymbols(start, start); |
|
} |
|
|
|
// The front end's turning from here: its phase isn't this one's, so the symbols don't follow on |
|
if (before < nbSymbols) |
|
{ |
|
m_awaitCorrection = 0; |
|
m_pendingCorrection = 0.0; |
|
m_pendingPhase = 0.0; |
|
m_pl.discontinuity(); |
|
const double resumed = now(); |
|
m_symbols.assign(symbols + before, symbols + nbSymbols); |
|
demodulateSymbols(resumed, resumed); |
|
} |
|
} |
|
|
|
void Receiver::demodulateSymbols(double start, double mid) |
|
{ |
|
// The matched filter's roll-off, for the samples from now on (shared, DVB-S's too: it's 0.35 but for a BBHEADER's) |
|
const double rollOff = m_rollOffSetting > 0.0 ? (double) m_rollOffSetting : (m_matypeRollOff >= 0 ? rollOffValue(m_matypeRollOff) : 0.35); |
|
|
|
if (shared()) { |
|
m_frontEndRollOff = rollOff; // Set by its owner, in its thread |
|
} else { |
|
m_fe->setRollOff(rollOff); |
|
} |
|
|
|
const bool searching = m_pl.getStatus().m_state != PLDecoder::State::Locked; |
|
int first = 0; |
|
|
|
// Searching, at a high symbol rate, could take more than a core (a correlation at every symbol, and headers to |
|
// decode where noise peaks): then windows of symbols are searched, with those between skipped |
|
if (searching && (m_skipSymbols > 0)) |
|
{ |
|
first = (int) std::min<int64_t>(m_skipSymbols, (int64_t) m_symbols.size()); |
|
m_skipSymbols -= first; |
|
|
|
if (m_skipSymbols == 0) { |
|
m_pl.discontinuity(); |
|
} |
|
} |
|
else if (!searching) |
|
{ |
|
// The search's time and symbols kept through brief locks: with gaps in the samples (the sample FIFO |
|
// overflowing), broken frames lock and lose lock again and again, and reset each time, the budget never |
|
// applied, so searching ran at full cost, slowing the receiver, so more was dropped |
|
m_skipSymbols = 0; |
|
m_lockedSymbols += (int64_t) m_symbols.size(); |
|
|
|
if (m_lockedSymbols > m_steadyLockSeconds * m_symbolRate) |
|
{ |
|
m_searchSeconds = 0.0; |
|
m_searchSymbols = 0; |
|
} |
|
} |
|
|
|
if (searching) { |
|
m_lockedSymbols = 0; |
|
} |
|
|
|
m_pl.process(m_symbols.data() + first, (int) m_symbols.size() - first); |
|
const uint64_t searched = searching ? m_symbols.size() - first : 0; |
|
|
|
if (searching && (first < (int) m_symbols.size())) |
|
{ |
|
m_searchSeconds += now() - mid; |
|
m_searchSymbols += (int64_t) m_symbols.size() - first; |
|
|
|
if (m_searchSymbols >= m_searchWindow) |
|
{ |
|
const double budget = std::max(m_minSearchBudget, std::min(m_searchBudget, m_threadBudget - m_otherLoad)); |
|
const int64_t wanted = (int64_t) (m_searchSeconds * m_symbolRate / budget); |
|
m_skipSymbols = std::max<int64_t>(0, std::min<int64_t>(wanted - m_searchSymbols, (int64_t) (m_maxSkipSeconds * m_symbolRate))); |
|
m_searchSeconds = 0.0; |
|
m_searchSymbols = 0; |
|
} |
|
} |
|
|
|
// The symbol clock's error from VL-SNR frames' slips, to the front end's timing loop |
|
const double clock = m_pl.takeClockCorrection(); |
|
|
|
if ((clock != 0.0) && !shared()) |
|
{ |
|
m_fe->adjustClock(clock); |
|
m_pl.clockCorrected(); |
|
} |
|
else if (clock != 0.0) |
|
{ |
|
// Made by the shared front end's owner between its blocks: in effect from the block whose status counts it |
|
m_clockRequested = m_clockRequested + clock; |
|
m_awaitClock = m_feStatus.m_clockAdjustments + 1; |
|
} |
|
|
|
// A large frequency offset goes to the front end's NCO |
|
const double correction = m_pl.takeFrequencyCorrection(); |
|
|
|
if ((correction != 0.0) && !shared()) |
|
{ |
|
m_fe->adjustFrequency(correction * m_symbolRate); |
|
} |
|
else if (correction != 0.0) |
|
{ |
|
// Asked of the shared front end's owner, made between its blocks: the symbols until then are skipped |
|
m_frequencyRequested = m_frequencyRequested + correction * m_symbolRate; |
|
m_awaitCorrection = ++m_frequencyRequests; |
|
m_pendingCorrection += correction; |
|
} |
|
|
|
const bool locked = m_pl.getStatus().m_state == PLDecoder::State::Locked; |
|
m_plLocked = locked; |
|
m_esn0 = m_pl.getStatus().m_esn0; |
|
|
|
// A shared one's owner decides these, from both receivers |
|
if (!shared()) |
|
{ |
|
m_fe->setTimingBandwidth(locked ? dvbs::FrontEnd::trackingBandwidth(m_timingTrack, m_esn0) |
|
: searchTimingBandwidth(m_fe->getStatus().m_spectralEsN0)); |
|
m_fe->setEqualiserReference(locked, m_pl.getStatus().m_esn0); |
|
} |
|
|
|
// Without frames for a while, the spectrum's measured again, in case the carrier was found wrong (or there was no |
|
// signal then): not sooner than the search could lock, nor while a header VL-SNR's search found waits for its next |
|
// (a frame on: at low symbol rates, seconds) |
|
if (locked || frontEndStatus().m_estimating) |
|
{ |
|
m_unlockedSymbols = 0; |
|
} |
|
else if (((m_unlockedSymbols += m_symbols.size()) > relockSeconds(m_symbolRate) * m_symbolRate) |
|
&& !m_pl.vlsnrCandidatePending()) |
|
{ |
|
restartFrontEnd(); |
|
m_pl.reset(); |
|
m_unlockedSymbols = 0; |
|
m_restarts++; |
|
} |
|
|
|
// Locked, but no frame decoded for a while: a false lock (on data repeating from frame to frame, that looks like a |
|
// header), or a signal too weak, so nothing's lost by starting again, with the spectrum measured again |
|
if (locked && (m_failedFrames >= m_maxFailedFrames)) |
|
{ |
|
if ((m_failingSymbols += m_symbols.size()) > m_failingSeconds * m_symbolRate) |
|
{ |
|
restartFrontEnd(); |
|
m_pl.reset(); |
|
m_failedFrames = 0; |
|
m_failingSymbols = 0; |
|
m_restarts++; |
|
} |
|
} |
|
else |
|
{ |
|
m_failingSymbols = 0; |
|
} |
|
|
|
const double end = now(); |
|
|
|
{ |
|
std::lock_guard<std::mutex> lock(m_demodMutex); |
|
Status& s = m_demodStatus; |
|
s.m_frontEnd = frontEndStatus(); |
|
s.m_pl = m_pl.getStatus(); |
|
s.m_symbolRate = m_symbolRate; |
|
s.m_rollOff = rollOff; |
|
s.m_frequencyOffset = s.m_frontEnd.m_frequencyOffset + (s.m_pl.m_inverted ? -1.0 : 1.0) * s.m_pl.m_frequency * m_symbolRate; |
|
s.m_clockOffset = s.m_frontEnd.m_clockOffset; |
|
s.m_restarts = m_restarts; |
|
s.m_searchedSymbols += searched; |
|
s.m_skippedSymbols += first; |
|
s.m_seconds[0] += mid - start; |
|
s.m_seconds[1] += end - mid; |
|
|
|
if (m_displayRequested) |
|
{ |
|
m_pl.getConstellation(m_displayCells, m_displayMaxCells); |
|
m_fe->getSpectrum(m_displaySpectrum, m_displayPoints); |
|
m_displayRequested = false; |
|
} |
|
} |
|
|
|
if (!m_threaded) |
|
{ |
|
decodeFramesCaught(m_pending); |
|
|
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
|
|
for (FrameSlot *slot : m_pending) { |
|
m_free.push_back(slot); |
|
} |
|
|
|
m_pending.clear(); |
|
} |
|
} |
|
|
|
// Below DVB-S2's MODCODs' thresholds (by the spectrum's estimate, with a margin), only VL-SNR frames can be received |
|
double Receiver::searchTimingBandwidth(double spectralEsN0) |
|
{ |
|
return spectralEsN0 >= -3.0 ? m_timingAcquire : dvbs::FrontEnd::trackingBandwidth(m_timingTrack, spectralEsN0); |
|
} |
|
|
|
// VL-SNR's search waits two of its frames, then needs a header and the next: at -6 dB, 3 s was too short below about |
|
// 33 kS/s, and it never locked |
|
double Receiver::relockSeconds(double symbolRate) |
|
{ |
|
return symbolRate > 0.0 ? std::max(m_minRelockSeconds, PLDecoder::acquisitionSymbols() / symbolRate) : m_minRelockSeconds; |
|
} |
|
|
|
// From the physical layer decoder, in the demodulator thread |
|
void Receiver::onFrame(XFECFrame& frame) |
|
{ |
|
std::unique_lock<std::mutex> lock(m_mutex); |
|
|
|
if (m_threaded && (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-S2 waiting for its FEC thread") |
|
} |
|
|
|
if (m_free.empty()) |
|
{ |
|
// More in use than expected (unthreaded, a call's many frames): another, made without the mutex |
|
lock.unlock(); |
|
std::unique_ptr<FrameSlot> spare(new FrameSlot()); |
|
lock.lock(); |
|
m_slots.push_back(std::move(spare)); |
|
m_free.push_back(m_slots.back().get()); |
|
} |
|
|
|
FrameSlot *slot = freeSlot(); |
|
std::swap(slot->m_frame, frame); // The decoder gets the slot's old buffers to fill next |
|
slot->m_epoch = m_resetEpoch; |
|
|
|
if (m_threaded) |
|
{ |
|
m_queue.push_back(slot); |
|
m_available.notify_one(); |
|
} |
|
else |
|
{ |
|
m_pending.push_back(slot); |
|
} |
|
} |
|
|
|
const Receiver::Code& Receiver::code(const XFECFrame& frame) |
|
{ |
|
// VL-SNR's after all the MODCODs' |
|
const FECType type = frame.m_fecType; |
|
const int key = frame.m_vlsnr >= 0 ? 2 * nbModcods + frame.m_vlsnr : frame.m_modcod * 2 + (type == FECType::Short ? 1 : 0); |
|
auto it = m_codes.find(key); |
|
|
|
if (it != m_codes.end()) { |
|
return *it->second; |
|
} |
|
|
|
const Modulation modulation = frame.m_modulation; |
|
const CodeRate rate = frame.m_rate; |
|
std::unique_ptr<Code> c(new Code()); |
|
c->m_vlsnr = frame.m_vlsnr; |
|
c->m_eta = bitsPerSymbol(modulation); |
|
|
|
// pi/2 BPSK (VL-SNR's) has neither: its cells are its bits'. VL-SNR's QPSK maps the bits sent, in order |
|
if (frame.m_vlsnr >= 0) |
|
{ |
|
if (modulation == Modulation::QPSK) |
|
{ |
|
constellation(modulation, rate, c->m_points, type); |
|
c->m_map.resize(2 * (size_t) vlsnrDataSymbols(vlsnrModcod(frame.m_vlsnr).m_set)); |
|
|
|
for (size_t i = 0; i < c->m_map.size(); i++) { |
|
c->m_map[i] = (int) i; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
bitMap(type, modulation, rate, c->m_map); |
|
constellation(modulation, rate, c->m_points, type); |
|
} |
|
|
|
if ((int) c->m_points.size() >= DemapTable::m_minPoints) { |
|
c->m_demapTable.build(c->m_points, c->m_eta); |
|
} |
|
|
|
c->m_kldpc = dvbt2::kldpc(type, rate, CodeFamily::S2); |
|
c->m_kbch = frame.m_vlsnr >= 0 ? vlsnrKbch(frame.m_vlsnr) : dvbt2::kbch(type, rate, CodeFamily::S2); |
|
c->m_bch.reset(new dvbt2::BCH(type, dvbt2::bchT(type, rate, CodeFamily::S2))); |
|
const Code& result = *c; |
|
m_codes[key] = std::move(c); |
|
return result; |
|
} |
|
|
|
// A batch of frames of the same code, by one thread: demapped, LDPC decoded together, each BCH decoded |
|
void Receiver::decodeBatch(dvbt2::LDPC& ldpc, dvbt2::LDPCPool::Context& context, std::vector<FrameSlot*>& frames, |
|
size_t first, size_t count, const Code& code) |
|
{ |
|
if (!context.m_scratch) { |
|
context.m_scratch.reset(new Scratch()); |
|
} |
|
|
|
Scratch& scratch = static_cast<Scratch&>(*context.m_scratch); |
|
std::vector<int8_t*> blocks(count); |
|
const int n = ldpc.n(); |
|
|
|
for (size_t i = 0; i < count; i++) |
|
{ |
|
FrameSlot& slot = *frames[first + i]; |
|
const XFECFrame& frame = slot.m_frame; |
|
const int cells = (int) frame.m_cells.size(); |
|
slot.m_llrs.resize(n); |
|
|
|
if (code.m_vlsnr >= 0) |
|
{ |
|
vlsnrLLRs(frame, code, slot.m_llrs.data(), n, scratch); |
|
} |
|
else |
|
{ |
|
const float scale = 4.0f / std::max(1e-6f, frame.m_noise); |
|
demap(frame.m_cells.data(), &scale, cells, code.m_points, code.m_eta, m_outlierThreshold, code.m_map.data(), |
|
slot.m_llrs.data(), nullptr, &code.m_demapTable, true); |
|
} |
|
|
|
blocks[i] = slot.m_llrs.data(); |
|
} |
|
|
|
// Frames probably cut by lost samples (the input overflowing, when the CPU can't keep up) aren't let hold up the |
|
// others: each held its batch to the iteration limit, about 10 times as long as the rest, taking the cores from |
|
// the front end and physical layer, so more samples were lost. They're given a few times the iterations the rest |
|
// took (all they can have at threshold, where a header's missed now and then, and the rest take many) |
|
uint64_t quick = 0; |
|
|
|
for (size_t i = 0; i < count; i++) |
|
{ |
|
if (frames[first + i]->m_frame.m_suspect) { |
|
quick |= 1ULL << i; |
|
} |
|
} |
|
|
|
int unconverged = 0; |
|
// VL-SNR's low rate codes, as EN 302 307-2 tables 20b and 20c's figures are for pi/2 BPSK: 75 iterations (their |
|
// frames carry little, so the time's small) |
|
const int maxIterations = code.m_vlsnr >= 0 ? std::max<int>(m_maxIterations, m_vlsnrIterations) : (int) m_maxIterations; |
|
const int iterations = ldpc.decode(blocks.data(), (int) count, maxIterations, &unconverged, quick); |
|
|
|
// BCH: the codeword is the LDPC's information bits (after a VL-SNR frame's shortened ones: a whole number of bytes), |
|
// from their signs, 8 at a time |
|
const int shortened = code.m_vlsnr >= 0 ? vlsnrModcod(code.m_vlsnr).m_xs : 0; |
|
|
|
for (size_t i = 0; i < count; i++) |
|
{ |
|
FrameSlot& slot = *frames[first + i]; |
|
const int8_t *llrs = slot.m_llrs.data() + shortened; |
|
slot.m_packed.resize((code.m_kldpc - shortened) / 8); |
|
|
|
for (size_t b = 0; b < slot.m_packed.size(); b++) |
|
{ |
|
uint64_t v; |
|
std::memcpy(&v, llrs + 8 * b, 8); |
|
v = (v >> 7) & 0x0101010101010101ULL; |
|
slot.m_packed[b] = (uint8_t) ((v * 0x8040201008040201ULL) >> 56); |
|
} |
|
|
|
slot.m_corrected = code.m_bch->decode(slot.m_packed.data(), (int) slot.m_packed.size()); |
|
} |
|
|
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
m_fecStatus.m_ldpcFailures += unconverged; |
|
m_fecStatus.m_ldpcIterations = m_fecStatus.m_fecFrames == 0 ? iterations : 0.95 * m_fecStatus.m_ldpcIterations + 0.05 * iterations; |
|
} |
|
|
|
void Receiver::vlsnrLLRs(const XFECFrame& frame, const Code& code, int8_t *llrs, int n, Scratch& scratch) |
|
{ |
|
const VLSNRModcod& m = vlsnrModcod(code.m_vlsnr); |
|
const int k = code.m_kldpc; |
|
const float limit = dvbt2::llrLimit; |
|
const Cf *cells = frame.m_cells.data(); |
|
const int nbCells = (int) frame.m_cells.size(); |
|
int cell = 0; |
|
|
|
// QPSK's from the demapper, as the bits sent; pi/2 BPSK's (on the real axis), 4 x / noise (twice the LLR, as the |
|
// demapper's), summed over a spread bit's cells |
|
std::vector<int8_t>& qpsk = scratch.m_cellLLRs; |
|
const float scale = 4.0f / std::max(1e-6f, frame.m_noise); |
|
qpsk.clear(); |
|
|
|
if ((m.m_modulation == Modulation::QPSK) && (2 * (size_t) nbCells == code.m_map.size())) |
|
{ |
|
qpsk.resize((size_t) 2 * nbCells); |
|
demap(cells, &scale, nbCells, code.m_points, 2, m_outlierThreshold, code.m_map.data(), qpsk.data(), nullptr, |
|
nullptr, true); |
|
} |
|
|
|
auto next = [&]() { |
|
if (!qpsk.empty()) { |
|
return cell < (int) qpsk.size() ? (float) qpsk[cell++] : 0.0f; |
|
} |
|
|
|
float sum = 0.0f; |
|
|
|
for (int s = 0; s < m.m_spreading; s++, cell++) { |
|
sum += cell < nbCells ? cells[cell].real() * scale : 0.0f; |
|
} |
|
|
|
return sum; |
|
}; |
|
|
|
for (int i = 0; i < n; i++) |
|
{ |
|
float v; |
|
|
|
if (i < m.m_xs) { |
|
v = limit; // Shortened: a zero |
|
} else if ((i >= k) && vlsnrPunctured(m, i - k)) { |
|
v = 0.0f; // Punctured: not sent |
|
} else { |
|
v = next(); |
|
} |
|
|
|
llrs[i] = (int8_t) std::lrint(std::max(-limit, std::min(limit, v))); |
|
} |
|
} |
|
|
|
// The frames, each code's in batches across the decoder threads, then their BBFRAMEs in order |
|
void Receiver::decodeFrames(std::vector<FrameSlot*>& frames) |
|
{ |
|
const double start = now(); |
|
|
|
// The frames of each code together, wherever they are in the batch (VCM and ACM interleave MODCODs frame by |
|
// frame): so the LDPC decoder's lanes are filled, and its decoders for each code not made again and again |
|
std::vector<std::vector<FrameSlot*>> groups; |
|
|
|
for (FrameSlot *slot : frames) |
|
{ |
|
if (slot->m_reset) { |
|
continue; |
|
} |
|
|
|
// A frame size and rate that don't go together (an undetected error in the PLS code) can't be decoded |
|
const XFECFrame& f = slot->m_frame; |
|
|
|
if (dvbt2::kldpc(f.m_fecType, f.m_rate, CodeFamily::S2) == 0) |
|
{ |
|
slot->m_skip = true; |
|
continue; |
|
} |
|
|
|
auto group = std::find_if(groups.begin(), groups.end(), [&f](const std::vector<FrameSlot*>& g) { |
|
return (g.front()->m_frame.m_modcod == f.m_modcod) && (g.front()->m_frame.m_fecType == f.m_fecType) |
|
&& (g.front()->m_frame.m_vlsnr == f.m_vlsnr); |
|
}); |
|
|
|
if (group == groups.end()) { |
|
groups.push_back({slot}); |
|
} else { |
|
group->push_back(slot); |
|
} |
|
} |
|
|
|
for (std::vector<FrameSlot*>& group : groups) |
|
{ |
|
const XFECFrame& f = group.front()->m_frame; |
|
const Code& c = code(f); |
|
const int lanes = m_context.decoder(CodeFamily::S2, f.m_fecType, f.m_rate).lanes(); |
|
const size_t count = group.size(); |
|
dvbt2::LDPCPool::Job job; |
|
job.m_family = CodeFamily::S2; |
|
job.m_type = f.m_fecType; |
|
job.m_rate = f.m_rate; |
|
job.m_batches = (int) ((count + lanes - 1) / lanes); |
|
job.m_decode = [&, count, lanes](dvbt2::LDPC& ldpc, dvbt2::LDPCPool::Context& context, int batch) { |
|
const size_t first = (size_t) batch * lanes; |
|
decodeBatch(ldpc, context, group, first, std::min((size_t) lanes, count - first), c); |
|
}; |
|
m_pool->run(job, m_context); |
|
} |
|
|
|
const double mid = now(); |
|
|
|
// Then in order, with any reset where it came: the packets of frames before it aren't wanted |
|
for (FrameSlot *slot : frames) |
|
{ |
|
if (slot->m_reset) { |
|
resetDecoding(*slot); |
|
} else if (!slot->m_skip) { |
|
deframe(*slot); |
|
} |
|
} |
|
|
|
// The packets for the caller's thread, unless there's been a reset since |
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
|
|
if (!m_bbPackets.empty()) |
|
{ |
|
if (m_decodeEpoch == m_resetEpoch) { |
|
m_packets.insert(m_packets.end(), m_bbPackets.begin(), m_bbPackets.end()); |
|
} |
|
|
|
m_bbPackets.clear(); |
|
} |
|
|
|
m_fecStatus.m_seconds[2] += mid - start; |
|
m_fecStatus.m_seconds[3] += now() - mid; |
|
m_fecStatus.m_bb = m_bbDecoder.stats(); |
|
m_fecStatus.m_streamPackets = m_streamPackets; |
|
} |
|
|
|
void Receiver::resetDecoding(const FrameSlot& slot) |
|
{ |
|
m_bbDecoder.reset(); |
|
m_bbPackets.clear(); |
|
clearStreams(); |
|
m_matypeRollOff = -1; // Of the signal before |
|
m_lowRollOffs = false; |
|
m_sinceLowRollOffs = 0; |
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
m_decodeEpoch = slot.m_epoch; |
|
m_fecStatus = Status(); |
|
} |
|
|
|
// Uncaught, an exception in the FEC thread ended the process (and unthreaded, the slots weren't returned) |
|
void Receiver::decodeFramesCaught(std::vector<FrameSlot*>& frames) |
|
{ |
|
try |
|
{ |
|
decodeFrames(frames); |
|
return; |
|
} |
|
catch (...) |
|
{ |
|
} |
|
|
|
try |
|
{ |
|
// A reset among them: its epoch reached, so the counts and packets after it are reported (if decodeFrames had |
|
// made it, made again: what it counted since is lost with the rest) |
|
auto reset = std::find_if(frames.rbegin(), frames.rend(), [](const FrameSlot *slot) { return slot->m_reset; }); |
|
|
|
if (reset != frames.rend()) { |
|
resetDecoding(**reset); |
|
} |
|
|
|
m_bbDecoder.discontinuity(); |
|
} |
|
catch (...) |
|
{ |
|
} |
|
|
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
m_fecStatus.m_fecErrors++; |
|
} |
|
|
|
void Receiver::clearStreams() |
|
{ |
|
m_isi = -1; |
|
m_streamPackets = 0; |
|
std::fill(m_isisSeen.begin(), m_isisSeen.end(), false); |
|
std::fill(m_isisNullOnly.begin(), m_isisNullOnly.end(), false); |
|
m_isiPackets = 0; |
|
m_isiNulls = 0; |
|
m_isiMissing = 0; |
|
} |
|
|
|
void Receiver::deframe(FrameSlot& slot) |
|
{ |
|
const XFECFrame& frame = slot.m_frame; |
|
const int kbch = frame.m_vlsnr >= 0 ? vlsnrKbch(frame.m_vlsnr) : dvbt2::kbch(frame.m_fecType, frame.m_rate, CodeFamily::S2); |
|
if (kbch <= 0) { |
|
qWarning() << "Receiver::deframe: Invalid BCH information length" << kbch; |
|
return; |
|
} |
|
const bool bad = slot.m_corrected < 0; |
|
dvbt2::scrambleBytes(slot.m_packed.data(), kbch / 8); |
|
dvbt2::BBFrameDecoder::Header header; |
|
const bool headerOK = dvbt2::BBFrameDecoder::parseHeader(slot.m_packed.data(), header) && (header.m_mode == 0); |
|
|
|
if (!bad && headerOK) { |
|
m_failedFrames = 0; |
|
} else { |
|
m_failedFrames++; |
|
} |
|
|
|
// Only a frame BCH corrected is trusted to choose the input stream or the roll-off: a BBHEADER of garbage passes its |
|
// CRC-8 one time in 256, and would select a stream that doesn't exist (every real frame then skipped) or switch |
|
// the matched filter |
|
const bool trusted = headerOK && !bad; |
|
|
|
{ |
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
Status& s = m_fecStatus; |
|
s.m_fecFrames++; |
|
s.m_bchFailures += bad; |
|
s.m_bchCorrected += std::max(0, slot.m_corrected); |
|
|
|
if (trusted) |
|
{ |
|
s.m_matypeRollOff = m_matypeRollOff; |
|
s.m_multipleStreams = !header.singleStream() || frame.m_timeSlicing; |
|
s.m_acm = (header.m_matype1 & 0x10) == 0; |
|
} |
|
} |
|
|
|
// Frames were lost before this one (perhaps of the stream decoded, whichever this one's of) |
|
if (frame.m_gap) { |
|
m_bbDecoder.discontinuity(); |
|
} |
|
|
|
if (trusted) |
|
{ |
|
// S2X's low roll-offs: RO alternates between 11 and their code (00 0.15, 01 0.10, 10 0.05), so without an 11 |
|
// for a few frames (some lost, in a multiple input stream another's), they've ended: the codes are S2's again |
|
if (header.rollOff() == 3) |
|
{ |
|
m_lowRollOffs = true; |
|
m_sinceLowRollOffs = 0; |
|
} |
|
else |
|
{ |
|
m_lowRollOffs = m_lowRollOffs && (++m_sinceLowRollOffs < m_lowRollOffFrames); |
|
|
|
// Not from a frame of before a reset (still being decoded when it came): the front end's set for the |
|
// signal since |
|
if (slot.m_epoch == m_resetEpoch) { |
|
m_matypeRollOff = header.rollOff() + (m_lowRollOffs ? 4 : 0); |
|
} |
|
} |
|
|
|
// In a multiple input stream, the one selected (or the first seen). Time slicing's (EN 302 307-1 Annex M) |
|
// slices are streams too, by their TSN (which may be the ISI, or not) |
|
if (!header.singleStream() || frame.m_timeSlicing) |
|
{ |
|
const int isi = frame.m_timeSlicing ? frame.m_tsn : header.m_matype2; |
|
|
|
if (!m_isisSeen[isi]) |
|
{ |
|
m_isisSeen[isi] = true; |
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
m_fecStatus.m_isiCount++; |
|
m_fecStatus.m_isis.insert(std::lower_bound(m_fecStatus.m_isis.begin(), m_fecStatus.m_isis.end(), isi), isi); |
|
} |
|
|
|
const int wanted = m_isiSetting; |
|
|
|
if (wanted >= 0) |
|
{ |
|
if (m_isi != wanted) |
|
{ |
|
m_isi = wanted; |
|
m_bbDecoder.discontinuity(); |
|
m_streamPackets = 0; // After: the discontinuity can give the last stream's packet held |
|
} |
|
} |
|
else if ((m_isi < 0) || (m_isiMissing >= m_missingStreamFrames)) |
|
{ |
|
if (m_isi >= 0) { |
|
m_bbDecoder.discontinuity(); |
|
} |
|
|
|
m_streamPackets = isi == m_isi ? m_streamPackets : 0; // After the discontinuity, as above |
|
m_isi = isi; |
|
m_isiPackets = 0; |
|
m_isiNulls = 0; |
|
m_isiMissing = 0; |
|
} |
|
else if ((m_isiPackets >= m_nullOnlyPackets) && (m_isiNulls == m_isiPackets)) |
|
{ |
|
// Chosen automatically, but carrying only null packets (as a stream of padding does): the next stream |
|
// seen that hasn't been found so, if there's one |
|
m_isisNullOnly[m_isi] = true; |
|
int next = -1; |
|
|
|
for (int k = 1; (k < 256) && (next < 0); k++) |
|
{ |
|
const int candidate = (m_isi + k) & 255; |
|
|
|
if (m_isisSeen[candidate] && !m_isisNullOnly[candidate]) { |
|
next = candidate; |
|
} |
|
} |
|
|
|
if (next >= 0) |
|
{ |
|
m_isi = next; |
|
m_bbDecoder.discontinuity(); |
|
m_streamPackets = 0; |
|
} |
|
|
|
m_isiPackets = 0; |
|
m_isiNulls = 0; |
|
} |
|
|
|
m_isiMissing = isi == m_isi ? 0 : m_isiMissing + 1; |
|
|
|
if (isi != m_isi) |
|
{ |
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
m_fecStatus.m_otherStreams++; |
|
return; |
|
} |
|
} |
|
else if (m_isi != -1) |
|
{ |
|
// From a multiple input stream to a single one: the packet the stream before was in the middle of isn't |
|
// this one's (its SYNCD could happen to fit), so dropped, as on switching streams |
|
m_isi = -1; |
|
m_bbDecoder.discontinuity(); |
|
m_streamPackets = 0; // After: the discontinuity can give the last stream's packet held |
|
} |
|
} |
|
else if (headerOK) |
|
{ |
|
// An untrusted frame isn't decoded unless its header says it's of the stream being decoded: in a multiple input |
|
// stream, not before one's chosen, and not one claiming a single stream (an ISI setting doesn't matter then) |
|
const int wanted = m_isiSetting; |
|
const int selected = wanted >= 0 ? wanted : m_isi.load(); |
|
|
|
const bool single = header.singleStream() && !frame.m_timeSlicing; |
|
|
|
if (single ? (m_isi >= 0) : ((frame.m_timeSlicing ? frame.m_tsn : header.m_matype2) != selected)) { |
|
return; |
|
} |
|
} |
|
|
|
m_bbDecoder.process(slot.m_packed.data(), kbch, bad); |
|
} |
|
|
|
void Receiver::runFEC() |
|
{ |
|
std::vector<FrameSlot*> frames; |
|
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; |
|
} |
|
|
|
// The LDPC decoder's lanes filled: a batch costs about the same however few of them there are. When the frames |
|
// are coming slower than they're decoded, they wait (a bounded time, so the delay is at low rates) for a full |
|
// batch, rather than each being decoded nearly alone as it comes. A reset (no frame) or an undecodable frame |
|
// decides nothing |
|
const FrameSlot *front = m_queue.front(); |
|
const XFECFrame& f = front->m_frame; |
|
const bool decodable = !front->m_reset && (dvbt2::kldpc(f.m_fecType, f.m_rate, CodeFamily::S2) != 0); |
|
size_t lanes = 1; |
|
|
|
if (decodable) |
|
{ |
|
// Outside the lock: a decoder for a code not seen yet is made here (its graph and tables), and the shared |
|
// thread queueing frames would wait for it. The queue may be emptied meanwhile (a reset) |
|
const FECType type = f.m_fecType; |
|
const CodeRate rate = f.m_rate; |
|
lock.unlock(); |
|
lanes = (size_t) std::max(1, m_context.decoder(CodeFamily::S2, type, rate).lanes()); |
|
lock.lock(); |
|
|
|
if (m_stop) { |
|
break; |
|
} |
|
|
|
if (m_queue.empty()) { |
|
continue; |
|
} |
|
} |
|
|
|
if (m_queue.size() < lanes) |
|
{ |
|
m_available.wait_for(lock, std::chrono::milliseconds(m_batchWaitMs), [this, lanes]() { |
|
return m_stop || m_draining || (m_queue.size() >= lanes); |
|
}); |
|
|
|
if (m_stop) { |
|
break; |
|
} |
|
} |
|
|
|
// Whole batches when there are more (so they fill when the frames come faster than they're decoded), the rest |
|
// left for the next with those that come meanwhile; everything when it's waited or is flushing. At most whole |
|
// rounds of the decoders: more, and the last round left decoders idle while those queued meanwhile waited (and |
|
// the slots in use, about 330 KB each, were up to twice the queue) |
|
size_t take = std::min(m_queue.size(), m_takeBatches * lanes); |
|
|
|
if (!m_draining && (take > lanes)) { |
|
take -= take % lanes; |
|
} |
|
|
|
frames.assign(m_queue.begin(), m_queue.begin() + take); |
|
m_queue.erase(m_queue.begin(), m_queue.begin() + take); |
|
m_busy = true; |
|
lock.unlock(); |
|
m_space.notify_all(); |
|
|
|
decodeFramesCaught(frames); |
|
|
|
lock.lock(); |
|
|
|
for (FrameSlot *slot : frames) { |
|
m_free.push_back(slot); |
|
} |
|
|
|
frames.clear(); |
|
m_busy = false; |
|
|
|
if (idle()) { |
|
m_idle.notify_all(); |
|
} |
|
} |
|
} |
|
|
|
// With m_mutex |
|
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 + 188 <= m_delivering.size(); i += 188) { |
|
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_draining = true; |
|
m_available.notify_one(); |
|
m_idle.wait(lock, [this] { return idle(); }); |
|
m_draining = false; |
|
} |
|
|
|
m_bbDecoder.flush(); |
|
|
|
{ |
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
|
|
if (!m_bbPackets.empty() && (m_decodeEpoch == m_resetEpoch)) { |
|
m_packets.insert(m_packets.end(), m_bbPackets.begin(), m_bbPackets.end()); |
|
} |
|
|
|
m_bbPackets.clear(); |
|
} |
|
|
|
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); |
|
// Until the FEC thread's reached a reset, its counts are still the signal's before (a batch being decoded |
|
// counts as it goes): none yet, rather than those |
|
static const Status none; |
|
const Status& f = m_decodeEpoch == m_resetEpoch ? m_fecStatus : none; |
|
status.m_matypeRollOff = f.m_matypeRollOff; |
|
status.m_multipleStreams = f.m_multipleStreams; |
|
status.m_acm = f.m_acm; |
|
status.m_isi = m_isi; |
|
status.m_streamPackets = f.m_streamPackets; |
|
status.m_isiCount = f.m_isiCount; |
|
status.m_isis = f.m_isis; |
|
status.m_fecFrames = f.m_fecFrames; |
|
status.m_ldpcFailures = f.m_ldpcFailures; |
|
status.m_fecErrors = f.m_fecErrors; |
|
status.m_bchFailures = f.m_bchFailures; |
|
status.m_bchCorrected = f.m_bchCorrected; |
|
status.m_ldpcIterations = f.m_ldpcIterations; |
|
status.m_otherStreams = f.m_otherStreams; |
|
status.m_bb = f.m_bb; |
|
status.m_queueWaits = m_queueWaits; |
|
status.m_seconds[2] = f.m_seconds[2]; |
|
status.m_seconds[3] = f.m_seconds[3]; |
|
} |
|
|
|
if (status.m_frontEnd.m_estimating) { |
|
status.m_state = State::Spectrum; |
|
} else if (status.m_pl.m_state != PLDecoder::State::Locked) { |
|
status.m_state = State::Searching; |
|
} else if (status.m_streamPackets == 0) { |
|
// Not until packets of the stream chosen: one selected that isn't sent decodes none, whatever came before |
|
status.m_state = State::Frames; |
|
} else { |
|
status.m_state = State::Locked; |
|
} |
|
|
|
return status; |
|
} |
|
|
|
void Receiver::getDisplayData(std::vector<Cf>& cells, int maxCells, std::vector<float>& spectrumDb, int points) const |
|
{ |
|
std::lock_guard<std::mutex> lock(m_demodMutex); |
|
cells = m_displayCells; |
|
spectrumDb = m_displaySpectrum; |
|
m_displayMaxCells = maxCells; |
|
m_displayPoints = points; |
|
m_displayRequested = true; |
|
} |
|
|
|
} // namespace dvbs2
|
|
|