/////////////////////////////////////////////////////////////////////////////////// // Copyright (C) 2026 Jon Beniston, M7RCE // // 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 . // /////////////////////////////////////////////////////////////////////////////////// #include "drmreceiver.h" #include "drmcellmap.h" #include "drmaudioframing.h" #include "drmchannelestimator.h" #include "drmmsc.h" #include "drmofdm.h" #include "drmparameters.h" #include #include #include #include #include #include #include namespace modemdrm { namespace { int firstTransmissionFrame(const FACAcquisitionResult& fac) { for (std::size_t i = 0; i < fac.facBlocks.size(); ++i) { if (fac.facBlocks[i].identity == 0 || fac.facBlocks[i].identity == 3) { return static_cast(i); } } return fac.coarse.mode == Mode::E ? 3 : -1; } // The raw gain-pilot channel observations of one symbol, zero elsewhere, in // the layout of an equalized symbol. EqualizedSymbol rawGainPilots( Mode mode, int occupancy, int symbol, int framePhase, int integerCarrierOffset, const std::vector>& bins ) { EqualizedSymbol result; const SpectrumParameters* spectrum = Parameters::forSpectrum(mode, occupancy); if (!spectrum || bins.empty()) { return result; } result.minimumCarrier = spectrum->minimumCarrier; result.maximumCarrier = spectrum->maximumCarrier; result.channel.assign(static_cast(spectrum->maximumCarrier - spectrum->minimumCarrier + 1), {}); const std::vector& references = CellMap::referenceCells(mode, occupancy, symbol, framePhase); const int size = static_cast(bins.size()); for (const PilotCell& pilot : references) { if (pilot.kind != ReferenceKind::Gain) { continue; } int index = (pilot.carrier + integerCarrierOffset) % size; if (index < 0) { index += size; } const double phase = 2.0 * 3.14159265358979323846 * pilot.phase1024 / 1024.0; const std::complex expected = pilot.amplitude * std::complex( static_cast(std::cos(phase)), static_cast(std::sin(phase))); result.channel[static_cast(pilot.carrier - spectrum->minimumCarrier)] = bins[static_cast(index)] / expected; } return result; } // An edge frame's continuity into the superframe, against the median of the // superframe's own frame-to-frame continuity (see decodeMSC). Sample counts // here and below are at the mode's reference rate (48 kHz for A-D, 192 kHz // for E): a timing estimate's spread in samples scales with the rate. constexpr double EdgeFrameCoherence = 0.9; constexpr double EdgeFrameShiftSamples = 2.0; constexpr double EdgeFramePhaseAgreement = 0.5; double referenceRateScale(Mode mode, int sampleRate) { const int reference = Parameters::forMode(mode).internalSampleRate; return reference > 0 && sampleRate > 0 ? static_cast(sampleRate) / reference : 1.0; } // How the raw pilots of one frame continue into the next: the median timing // shift of the valid PilotTimingTracker::compare estimates and the mean // coherence over the symbols (each symbol index has the same gain-reference // carriers in every frame). A slip of one gain-pilot comb period (N/6 samples // in mode B, for example) aliases to no shift with full per-symbol coherence, // but turns each symbol's common phase by a different amount (2 pi k0 / 6 for // a comb from carrier k0), so the symbols must also agree on it: the // coherence-weighted mean of their phasors at least EdgeFramePhaseAgreement // of the mean coherence (an aliased slip of a three-comb mode gives near 0). // Requiring half the symbols valid, or scaling the coherence by the phase // agreement, cost Kuwait 10:02 44 frames. struct FrameContinuity { bool valid = false; double shiftSamples = 0.0; double coherence = 0.0; }; FrameContinuity frameContinuity( Mode mode, int occupancy, int integerCarrierOffset, int sampleRate, const std::vector>>& first, int firstPhase, const std::vector>>& second, int secondPhase ) { FrameContinuity result; const ModeParameters& parameters = Parameters::forMode(mode); std::vector validShifts; double coherence = 0.0; std::complex commonPhase(0.0, 0.0); for (int symbol = 0; symbol < parameters.symbolsPerFrame; ++symbol) { const EqualizedSymbol a = rawGainPilots(mode, occupancy, symbol, firstPhase, integerCarrierOffset, first[static_cast(symbol)]); const EqualizedSymbol b = rawGainPilots(mode, occupancy, symbol, secondPhase, integerCarrierOffset, second[static_cast(symbol)]); const PilotTimingEstimate estimate = PilotTimingTracker::compare(a, b, parameters.usefulSamples(sampleRate)); coherence += estimate.coherence; commonPhase += static_cast(estimate.coherence) * std::polar(1.0, estimate.commonPhaseRadians); if (estimate.valid) { validShifts.push_back(estimate.timingShiftSamples); } } if (validShifts.empty() || !(coherence > 0.0) || std::abs(commonPhase) < EdgeFramePhaseAgreement * coherence) { return result; } const auto middle = validShifts.begin() + static_cast(validShifts.size() / 2U); std::nth_element(validShifts.begin(), middle, validShifts.end()); result.valid = true; result.shiftSamples = *middle; result.coherence = coherence / static_cast(parameters.symbolsPerFrame); return result; } bool demodulateFrames( const std::complex* samples, std::size_t sampleCount, int sampleRate, Mode mode, std::size_t firstFrameStart, int frameCount, int occupancy, int firstFrameInSuperframe, int integerCarrierOffset, double fractionalCarrierOffsetHz, bool spectralInversion, std::vector>>>& spectra, double* sampleClockErrorPPM = nullptr, SampleClockState* sampleClock = nullptr ) { const ModeParameters& parameters = Parameters::forMode(mode); const int symbolSamples = parameters.symbolSamples(sampleRate); spectra.assign( static_cast(frameCount), std::vector>>( static_cast(parameters.symbolsPerFrame) ) ); OFDMDemodulator demodulator(mode, sampleRate); std::vector previousPilots; SampleClockState localClock; SampleClockState& clock = sampleClock ? *sampleClock : localClock; // The caller re-anchors the first frame from fresh timing each call, so // prediction restarts at zero; only the drift rate is carried over. Keep // the steering well inside the guard interval. const double maximumPrediction = demodulator.guardSamples() / 4.0; const double rateScale = referenceRateScale(mode, sampleRate); double predictedCorrection = 0.0; long long previousCorrection = 0; const long long frameSamples = static_cast( parameters.symbolsPerFrame * symbolSamples ); for (int frame = 0; frame < frameCount; ++frame) { const long long nominalFrameStart = static_cast(firstFrameStart) + static_cast(frame) * frameSamples; long long frameCorrection = std::llround(predictedCorrection); const long long minimumCorrection = -nominalFrameStart; const long long finalNominalPrefix = nominalFrameStart + static_cast(parameters.symbolsPerFrame - 1) * symbolSamples; const long long maximumCorrection = static_cast(sampleCount) - finalNominalPrefix - demodulator.guardSamples() - demodulator.usefulSamples(); if (maximumCorrection < minimumCorrection) { return false; } frameCorrection = std::clamp( frameCorrection, minimumCorrection, maximumCorrection ); for (int symbol = 0; symbol < parameters.symbolsPerFrame; ++symbol) { const std::size_t prefixStart = static_cast( nominalFrameStart + frameCorrection + static_cast(symbol) * symbolSamples ); if (!demodulator.demodulate( samples, sampleCount, prefixStart, fractionalCarrierOffsetHz, spectra[static_cast(frame)][static_cast(symbol)], spectralInversion)) { return false; } } std::vector currentPilots( static_cast(parameters.symbolsPerFrame) ); const int framePhase = (firstFrameInSuperframe + frame) % parameters.framesPerSuperframe; bool pilotsValid = true; // Timing drift from the raw pilots only: estimates interpolated // between pilots alias on a frequency-selective channel, change from // frame to frame under fading, and can still look coherent. for (int symbol = 0; symbol < parameters.symbolsPerFrame; ++symbol) { const auto& bins = spectra[static_cast(frame)][static_cast(symbol)]; currentPilots[static_cast(symbol)] = rawGainPilots( mode, occupancy, symbol, framePhase, integerCarrierOffset, bins); pilotsValid = pilotsValid && !currentPilots[static_cast(symbol)].channel.empty(); } if (pilotsValid && !previousPilots.empty()) { std::vector shifts; shifts.reserve(static_cast(parameters.symbolsPerFrame)); for (int symbol = 0; symbol < parameters.symbolsPerFrame; ++symbol) { const PilotTimingEstimate estimate = PilotTimingTracker::compare( previousPilots[static_cast(symbol)], currentPilots[static_cast(symbol)], demodulator.usefulSamples() ); if (estimate.valid && estimate.coherence >= 0.8f && std::abs(estimate.timingShiftSamples) <= 4.0 * rateScale) { shifts.push_back(estimate.timingShiftSamples); } } if (shifts.size() >= static_cast( std::max(3, parameters.symbolsPerFrame / 3))) { const auto middle = shifts.begin() + static_cast(shifts.size() / 2U); std::nth_element(shifts.begin(), middle, shifts.end()); const double measuredErrorChange = *middle; const double appliedChange = static_cast( frameCorrection - previousCorrection ); const double observedDrift = std::clamp( appliedChange - measuredErrorChange, -4.0 * rateScale, 4.0 * rateScale ); clock.driftPerFrame = clock.haveDrift ? 0.8 * clock.driftPerFrame + 0.2 * observedDrift : observedDrift; clock.haveDrift = true; if (clock.observations < 1000000) { ++clock.observations; } } } previousPilots = std::move(currentPilots); previousCorrection = frameCorrection; if (clock.observations >= 2) { predictedCorrection = std::clamp(predictedCorrection + clock.driftPerFrame, -maximumPrediction, maximumPrediction); } // Moving an FFT window by an integer sample rotates every carrier by // a different phase. Keep the raw pilots above for drift measurement, // but return spectra in the nominal window's phase reference so the // temporal channel estimator does not interpolate across a phase jump. if (frameCorrection != 0) { const int usefulSamples = demodulator.usefulSamples(); std::vector> phase(static_cast(usefulSamples)); for (int bin = 0; bin < usefulSamples; ++bin) { phase[static_cast(bin)] = std::polar(1.0f, static_cast(-2.0 * std::acos(-1.0) * frameCorrection * bin / usefulSamples)); } for (auto& symbol : spectra[static_cast(frame)]) { for (int bin = 0; bin < usefulSamples; ++bin) { symbol[static_cast(bin)] *= phase[static_cast(bin)]; } } } } if (sampleClockErrorPPM) { *sampleClockErrorPPM = clock.haveDrift ? clock.driftPerFrame * 1.0e6 / static_cast(frameSamples) : 0.0; } return true; } bool audioCodingSupported( const AudioDecoderCapabilities& capabilities, const SDCAudioInformation& audio ) { return (audio.audioCoding == 0 && capabilities.aac) || (audio.audioCoding == 3 && capabilities.xheAAC); } // The nearest level on one axis of the MSC constellation: an odd multiple of // the axis scale, up to the constellation's largest. struct AxisDecision { AxisDecision(Mode mode, int mscMode) { if (mode == Mode::E && mscMode == 3) { maximum = 1.0f; scale = 0.70710678118654752f; // 4-QAM, 1/sqrt(2) } else if (mscMode == 3 || mode == Mode::E) { maximum = 3.0f; scale = 0.31622776601683794f; // 16-QAM, 1/sqrt(10) } else { maximum = 7.0f; scale = 0.15430334996209191f; // 64-QAM, 1/sqrt(42) } } float operator()(float received) const { const float level = std::clamp(received / scale, -maximum, maximum); return scale * std::clamp(2.0f * std::floor(0.5f * level) + 1.0f, -maximum, maximum); } float scale = 1.0f; float maximum = 1.0f; }; void accumulateDecisionDirectedMER( Mode mode, int mscMode, const MSCMultiplexFrameCells& frame, double& referencePower, double& errorPower, std::size_t& cellCount ) { const AxisDecision nearestAxis(mode, mscMode); for (std::size_t i = 0; i < frame.cells.size(); ++i) { if (i < frame.reliabilities.size() && frame.reliabilities[i] <= 0.0f) { continue; } const auto& received = frame.cells[i]; const std::complex decided( nearestAxis(received.real()), nearestAxis(received.imag()) ); referencePower += std::norm(decided); errorPower += std::norm(received - decided); ++cellCount; } } // MSC soft bits are weighted by |H|, which is right when every cell's error is // receiver noise: N0/|H|^2 after equalization. Error that scales with the // channel, a transmitter's own modulation error above all, is the same on // every equalized cell instead, so a strong carrier is not as reliable as |H| // says. The superframe's pilots measure both terms (error power N0 + F |H|^2, // see EqualizedSymbol::pilotErrors), without decisions, which saturate at low // SNR. Each cell is then weighted by |H| / sqrt(1 + s (F/N0) |H|^2), rescaled // to the superframe's mean |H| so that superframes mixed by the deinterleaver // keep their relative scale. At F/N0 near zero (the annex B channels, BBC) // this is |H|. Kuwait 10:02 (F/N0 about 3 at the mean channel power, a floor // near 17 dB) decodes 3,646 frames instead of 1,976; the A-D sweep keeps // 14,829 of 14,834 frames and the mode E sweep gains (7,221 against 7,219). A scale s of // 0.5 was best: 1 and 2 cost the sweeps more for little more on Kuwait. constexpr double ErrorFloorWeightScale = 0.5; constexpr double MinimumPilotErrors = 20.0; void weightForErrorFloor(std::vector& frames, const std::vector& errors, const std::vector& excludedCarriers, int minimumCarrier) { // Carriers an interferer raises (see weightForCarrierNoise, as measured // up to the previous superframe) would inflate the slope; leaving them // out gained Kuwait 10:02 8 frames and 11:19 2. EqualizedSymbol::PilotErrorSums sums; for (const EqualizedSymbol::PilotError& error : errors) { const int index = error.carrier - minimumCarrier; if (index >= 0 && index < static_cast(excludedCarriers.size()) && excludedCarriers[static_cast(index)]) { continue; } sums.add(error); } if (sums.count < MinimumPilotErrors) { return; } const double denominator = sums.count * sums.xx - sums.x * sums.x; if (!(denominator > 0.0)) { return; } const double slope = std::max(0.0, (sums.count * sums.xy - sums.x * sums.y) / denominator); // The intercept can fit negative when the floor dominates; bound it by a // small share of the mean error. const double intercept = std::max((sums.y - slope * sums.x) / sums.count, 0.01 * sums.y / sums.count); const double ratio = ErrorFloorWeightScale * slope / intercept; if (!(ratio > 0.0)) { return; } double before = 0.0; double after = 0.0; for (const MSCFrameCells& frame : frames) { for (float h : frame.reliabilities) { if (h <= 0.0f) { continue; } before += h; after += h / std::sqrt(1.0 + ratio * static_cast(h) * h); } } if (!(after > 0.0)) { return; } const double scale = before / after; for (MSCFrameCells& frame : frames) { for (float& h : frame.reliabilities) { if (h > 0.0f) { h = static_cast(scale * h / std::sqrt(1.0 + ratio * static_cast(h) * h)); } } } } // A narrowband interferer raises the noise of a few carriers (RFmondial // 16-QAM: carriers 34-38 at up to 7.7 times the median; BBC: a tone on carrier // -64), which |H| does not see. Each carrier's decision error, scaled by the // cells' reliabilities, over the superframe's stronger cells (whose decisions // saturate least) is // compared with the median over carriers, and a carrier above twice the median // is weighted down by the square root of the excess. Where the noise is // flat (the annex B channels) no carrier is above the threshold. With the // error-floor weighting: Kuwait 10:02 3,658 frames (3,646), Kuwait 11:19 736 // (726), RFmondial 4-QAM 5,500 (5,493, now nothing concealed), the A-D sweep // 14,833 (14,829). Keeping each carrier's latest measurement (CarrierNoiseHistory) // mattered (without it Kuwait 10:02 decoded 3,621); averaging over superframes // did no better. constexpr double CarrierNoiseThreshold = 2.0; constexpr double CarrierNoiseExponent = 0.5; constexpr double CarrierNoiseStrongCells = 0.5; // of the mean channel power constexpr double CarrierNoiseMinimumCells = 4.0; constexpr int CarrierNoiseMaximumAge = 10; // superframes without a measurement // Carriers whose kept noise measurement is above the threshold, from the lowest. std::vector noisyCarriers(Mode mode, int occupancy, int mscMode, const CarrierNoiseHistory& history) { if (history.mode != static_cast(mode) || history.occupancy != occupancy || history.mscMode != mscMode) { return {}; } std::vector measured; for (double n : history.noise) { if (n >= 0.0) { measured.push_back(n); } } if (measured.size() < 16U) { return {}; } std::nth_element(measured.begin(), measured.begin() + static_cast(measured.size() / 2U), measured.end()); const double limit = CarrierNoiseThreshold * measured[measured.size() / 2U]; if (!(limit > 0.0)) { return {}; } std::vector noisy(history.noise.size(), false); for (std::size_t carrier = 0; carrier < noisy.size(); ++carrier) { noisy[carrier] = history.noise[carrier] > limit; } return noisy; } // An erased superframe measures nothing: its carriers' measurements age. void ageCarrierNoise(CarrierNoiseHistory& history) { for (std::size_t carrier = 0; carrier < history.noise.size() && carrier < history.age.size(); ++carrier) { if (history.noise[carrier] >= 0.0 && ++history.age[carrier] > CarrierNoiseMaximumAge) { history.noise[carrier] = -1.0; } } } void weightForCarrierNoise(Mode mode, int occupancy, int mscMode, std::vector& frames, CarrierNoiseHistory& history) { const SpectrumParameters* spectrum = Parameters::forSpectrum(mode, occupancy); if (!spectrum) { return; } const int carriers = spectrum->maximumCarrier - spectrum->minimumCarrier + 1; // Decision errors compare only within one constellation. if (history.mode != static_cast(mode) || history.occupancy != occupancy || history.mscMode != mscMode || static_cast(history.noise.size()) != carriers) { history.mode = static_cast(mode); history.occupancy = occupancy; history.mscMode = mscMode; history.noise.assign(static_cast(carriers), -1.0); history.age.assign(static_cast(carriers), 0); } const AxisDecision nearestAxis(mode, mscMode); double meanPower = 0.0; double cells = 0.0; for (const MSCFrameCells& frame : frames) { for (float h : frame.reliabilities) { if (h > 0.0f) { meanPower += static_cast(h) * h; cells += 1.0; } } } if (!(cells > 0.0)) { return; } meanPower /= cells; std::vector errorSum(static_cast(carriers), 0.0); std::vector errorCount(static_cast(carriers), 0.0); for (std::size_t phase = 0; phase < frames.size(); ++phase) { const auto& positions = CellMap::mscCells(mode, occupancy, static_cast(phase)); const MSCFrameCells& frame = frames[phase]; for (std::size_t i = 0; i < positions.size() && i < frame.cells.size(); ++i) { const double h2 = static_cast(frame.reliabilities[i]) * frame.reliabilities[i]; if (h2 < CarrierNoiseStrongCells * meanPower) { continue; } const std::complex y = frame.cells[i]; const std::complex decided(nearestAxis(y.real()), nearestAxis(y.imag())); const std::size_t carrier = static_cast(positions[i].carrier - spectrum->minimumCarrier); // Relative to the superframe's channel power, so that measurements // kept from earlier superframes compare. errorSum[carrier] += h2 * std::norm(y - decided) / meanPower; errorCount[carrier] += 1.0; } } // A carrier with too few strong cells this superframe (deep in a fade) // keeps its last measurement, for a while: an interferer can leave. std::vector& noise = history.noise; std::vector measured; for (std::size_t carrier = 0; carrier < noise.size(); ++carrier) { if (errorCount[carrier] >= CarrierNoiseMinimumCells) { noise[carrier] = errorSum[carrier] / errorCount[carrier]; history.age[carrier] = 0; } else if (noise[carrier] >= 0.0 && ++history.age[carrier] > CarrierNoiseMaximumAge) { noise[carrier] = -1.0; } if (noise[carrier] >= 0.0) { measured.push_back(noise[carrier]); } } if (measured.size() < 16U) { return; } std::nth_element(measured.begin(), measured.begin() + static_cast(measured.size() / 2U), measured.end()); const double limit = CarrierNoiseThreshold * measured[measured.size() / 2U]; if (!(limit > 0.0)) { return; } for (std::size_t phase = 0; phase < frames.size(); ++phase) { const auto& positions = CellMap::mscCells(mode, occupancy, static_cast(phase)); MSCFrameCells& frame = frames[phase]; for (std::size_t i = 0; i < positions.size() && i < frame.reliabilities.size(); ++i) { const double n = noise[static_cast(positions[i].carrier - spectrum->minimumCarrier)]; if (n > limit) { frame.reliabilities[i] *= static_cast(std::pow(limit / n, CarrierNoiseExponent)); } } } } const FACService* findFACService( const FACAcquisitionResult& fac, std::int64_t serviceIdentifier ) { for (const FACData& block : fac.facBlocks) { for (const FACService& service : block.services) { if (serviceIdentifier < 0 || service.serviceIdentifier == static_cast(serviceIdentifier)) { return &service; } } } return nullptr; } bool sameMultiplex(const SDCMultiplexDescription& lhs, const SDCMultiplexDescription& rhs) { return lhs.present == rhs.present && lhs.nextConfiguration == rhs.nextConfiguration && lhs.protectionLevelA == rhs.protectionLevelA && lhs.protectionLevelB == rhs.protectionLevelB && std::equal(lhs.streams.begin(), lhs.streams.end(), rhs.streams.begin(), rhs.streams.end(), [](const SDCStreamDescription& left, const SDCStreamDescription& right) { return left.streamId == right.streamId && left.partALengthBytes == right.partALengthBytes && left.partBLengthBytes == right.partBLengthBytes; }); } bool sameAudio(const SDCAudioInformation& lhs, const SDCAudioInformation& rhs) { return lhs.nextConfiguration == rhs.nextConfiguration && lhs.shortId == rhs.shortId && lhs.streamId == rhs.streamId && lhs.audioCoding == rhs.audioCoding && lhs.sbr == rhs.sbr && lhs.audioMode == rhs.audioMode && lhs.samplingRateCode == rhs.samplingRateCode && lhs.text == rhs.text && lhs.enhancement == rhs.enhancement && lhs.coderField == rhs.coderField && lhs.codecSpecificConfig == rhs.codecSpecificConfig; } bool sameSDCEntity(const SDCEntity& lhs, const SDCEntity& rhs) { return lhs.type == rhs.type && lhs.version == rhs.version && lhs.lengthBytes == rhs.lengthBytes && lhs.bodyBits == rhs.bodyBits; } bool replacesSDCEntity(const SDCEntity& current, const SDCEntity& received) { if (current.type != received.type) { return false; } if ((received.type == 0 || received.type == 9) && current.version != received.version) { return false; } switch (received.type) { case 0: case 8: return true; case 1: case 9: case 12: return current.bodyBits.size() >= 2U && received.bodyBits.size() >= 2U && current.bodyBits[0] == received.bodyBits[0] && current.bodyBits[1] == received.bodyBits[1]; default: return false; } } bool mergeSDCDataInternal(SDCData& aggregate, const SDCData& block) { if (!block.valid) { return false; } // A list-decoded block can match the CRC by coincidence. When it // contradicts a live database (another AFS index, another multiplex, or // another audio descriptor for a known service, which would reconfigure // the codec), take nothing from it: hold it until a second block agrees. const bool liveMultiplex = block.multiplex.present && !block.multiplex.nextConfiguration; if (block.listDecoded && aggregate.valid && aggregate.multiplex.present && (aggregate.afsIndex != block.afsIndex || (liveMultiplex && !sameMultiplex(aggregate.multiplex, block.multiplex)))) { const bool confirmed = aggregate.unconfirmedAFSIndex == block.afsIndex && liveMultiplex && aggregate.unconfirmedMultiplex.present && sameMultiplex(aggregate.unconfirmedMultiplex, block.multiplex); if (!confirmed) { aggregate.unconfirmedMultiplex = liveMultiplex ? block.multiplex : SDCMultiplexDescription(); aggregate.unconfirmedAFSIndex = block.afsIndex; return false; } } else if (block.listDecoded && aggregate.valid && aggregate.afsIndex == block.afsIndex) { // Per service: a change is confirmed by a second block with the same // descriptor, otherwise held (replacing an earlier held one). bool hold = false; for (const SDCAudioInformation& audio : block.audio) { const auto existing = std::find_if(aggregate.audio.begin(), aggregate.audio.end(), [&audio](const SDCAudioInformation& item) { return item.shortId == audio.shortId; }); if (existing == aggregate.audio.end() || sameAudio(*existing, audio)) { continue; } const auto held = std::find_if(aggregate.unconfirmedAudio.begin(), aggregate.unconfirmedAudio.end(), [&audio](const SDCAudioInformation& item) { return item.shortId == audio.shortId; }); if (held != aggregate.unconfirmedAudio.end() && sameAudio(*held, audio)) { continue; } if (held != aggregate.unconfirmedAudio.end()) { *held = audio; } else { aggregate.unconfirmedAudio.push_back(audio); } hold = true; } if (hold) { return false; } } // A merged descriptor settles any change held for its service. for (const SDCAudioInformation& audio : block.audio) { aggregate.unconfirmedAudio.erase(std::remove_if(aggregate.unconfirmedAudio.begin(), aggregate.unconfirmedAudio.end(), [&audio](const SDCAudioInformation& held) { return held.shortId == audio.shortId; }), aggregate.unconfirmedAudio.end()); } if (!aggregate.valid || aggregate.afsIndex != block.afsIndex) { aggregate = SDCData(); aggregate.valid = true; aggregate.afsIndex = block.afsIndex; } aggregate.listDecoded = aggregate.listDecoded || block.listDecoded; // Version 0 describes the configuration currently carried by the MSC. // Keep version-1 entities in the raw entity list for later atomic // reconfiguration handling, but never apply them to the live decoder. if (liveMultiplex) { aggregate.multiplex = block.multiplex; aggregate.unconfirmedMultiplex = SDCMultiplexDescription(); aggregate.unconfirmedAFSIndex = -1; } if (block.nextMultiplex.present && block.nextMultiplex.nextConfiguration) { aggregate.nextMultiplex = block.nextMultiplex; } // A service can carry several data components, one per packet Id. for (const SDCDataApplication& application : block.dataApplications) { const auto existing = std::find_if( aggregate.dataApplications.begin(), aggregate.dataApplications.end(), [&application](const SDCDataApplication& item) { return item.shortId == application.shortId && item.streamId == application.streamId && item.packetId == application.packetId; } ); if (existing == aggregate.dataApplications.end()) { aggregate.dataApplications.push_back(application); } else { *existing = application; } } for (const SDCLabel& label : block.labels) { const auto existing = std::find_if( aggregate.labels.begin(), aggregate.labels.end(), [&label](const SDCLabel& item) { return item.shortId == label.shortId; } ); if (existing == aggregate.labels.end()) { aggregate.labels.push_back(label); } else { *existing = label; } } if (block.timeDate.present) { aggregate.timeDate = block.timeDate; } for (const SDCAudioInformation& audio : block.audio) { const auto existing = std::find_if( aggregate.audio.begin(), aggregate.audio.end(), [&audio](const SDCAudioInformation& item) { return !item.nextConfiguration && item.shortId == audio.shortId; } ); if (existing == aggregate.audio.end()) { aggregate.audio.push_back(audio); } else { *existing = audio; } } for (const SDCAudioInformation& audio : block.nextAudio) { const auto existing = std::find_if( aggregate.nextAudio.begin(), aggregate.nextAudio.end(), [&audio](const SDCAudioInformation& item) { return item.nextConfiguration && item.shortId == audio.shortId; } ); if (existing == aggregate.nextAudio.end()) { aggregate.nextAudio.push_back(audio); } else { *existing = audio; } } for (const SDCLanguageCountry& language : block.languageCountries) { const auto existing = std::find_if( aggregate.languageCountries.begin(), aggregate.languageCountries.end(), [&language](const SDCLanguageCountry& item) { return item.shortId == language.shortId; } ); if (existing == aggregate.languageCountries.end()) { aggregate.languageCountries.push_back(language); } else { *existing = language; } } for (const SDCAlternativeFrequencyEntity& afs : block.alternativeFrequencies) { const auto sameType = [&afs](const SDCAlternativeFrequencyEntity& item) { return item.type == afs.type; }; const auto first = std::find_if( aggregate.alternativeFrequencies.begin(), aggregate.alternativeFrequencies.end(), sameType ); if (first != aggregate.alternativeFrequencies.end() && first->listVersion != afs.listVersion) { aggregate.alternativeFrequencies.erase( std::remove_if( aggregate.alternativeFrequencies.begin(), aggregate.alternativeFrequencies.end(), sameType ), aggregate.alternativeFrequencies.end() ); } const auto duplicate = std::find_if( aggregate.alternativeFrequencies.begin(), aggregate.alternativeFrequencies.end(), [&afs](const SDCAlternativeFrequencyEntity& item) { return item.type == afs.type && item.listVersion == afs.listVersion && item.bodyBits == afs.bodyBits; } ); if (duplicate == aggregate.alternativeFrequencies.end() && aggregate.alternativeFrequencies.size() < SDCData::MaximumAFSEntities) { aggregate.alternativeFrequencies.push_back(afs); } } for (const SDCEntity& entity : block.entities) { const auto replacement = std::find_if(aggregate.entities.begin(), aggregate.entities.end(), [&entity](const SDCEntity& item) { return replacesSDCEntity(item, entity); }); if (replacement != aggregate.entities.end()) { *replacement = entity; continue; } // An AFS version toggle replaces its old raw list as well as the parsed // list. Other optional/unknown entities remain bounded diagnostics. if (entity.type == 3 || entity.type == 4 || entity.type == 7 || entity.type == 11 || entity.type == 13 || entity.type == 15) { aggregate.entities.erase(std::remove_if(aggregate.entities.begin(), aggregate.entities.end(), [&entity](const SDCEntity& item) { return item.type == entity.type && item.version != entity.version; }), aggregate.entities.end()); } if (std::none_of(aggregate.entities.begin(), aggregate.entities.end(), [&entity](const SDCEntity& item) { return sameSDCEntity(item, entity); })) { if (aggregate.entities.size() == SDCData::MaximumRawEntities) { // Prefer evicting optional diagnostics, preserving current and // pending multiplex/audio entries even when the list is full. const auto optional = std::find_if(aggregate.entities.begin(), aggregate.entities.end(), [](const SDCEntity& item) { return item.type != 0 && item.type != 9; }); if (optional != aggregate.entities.end()) { aggregate.entities.erase(optional); } } if (aggregate.entities.size() < SDCData::MaximumRawEntities) { aggregate.entities.push_back(entity); } } } return true; } } // namespace bool SDCParser::mergeBlock(SDCData& aggregate, const SDCData& block) { return mergeSDCDataInternal(aggregate, block); } bool SDCParser::promoteNextConfiguration(SDCData& data) { if (!data.nextMultiplex.present) { return false; } data.multiplex = std::move(data.nextMultiplex); data.multiplex.nextConfiguration = false; data.nextMultiplex = SDCMultiplexDescription(); if (!data.nextAudio.empty()) { data.audio = std::move(data.nextAudio); } else { // No version-1 audio entity was received before the boundary. Keep // the current descriptors whose streams survive, rather than leaving // no audio until the next SDC cycle; version-0 entities after the // boundary replace them. const auto& streams = data.multiplex.streams; data.audio.erase(std::remove_if(data.audio.begin(), data.audio.end(), [&streams](const SDCAudioInformation& audio) { return std::none_of(streams.begin(), streams.end(), [&audio](const SDCStreamDescription& stream) { return stream.streamId == audio.streamId; }); }), data.audio.end()); } for (SDCAudioInformation& audio : data.audio) { audio.nextConfiguration = false; } // Version-1 data entities are not kept (a component may move to another // stream or packet Id): the new configuration's arrive as version 0. data.dataApplications.clear(); data.nextAudio.clear(); return true; } int DRMReceiver::maximumCompleteSuperframes( std::size_t sampleCount, int sampleRate, const FACAcquisitionResult& fac ) { if (sampleRate <= 0 || !fac.valid || fac.facBlocks.empty()) { return 0; } const int firstFrame = firstTransmissionFrame(fac); if (firstFrame < 0) { return 0; } const ModeParameters& parameters = Parameters::forMode(fac.coarse.mode); const std::size_t frameSamples = static_cast( parameters.symbolsPerFrame * parameters.symbolSamples(sampleRate) ); const std::size_t firstFrameStart = fac.frameStartOffsetSamples + static_cast(firstFrame) * frameSamples; if (frameSamples == 0 || firstFrameStart >= sampleCount) { return 0; } const std::size_t availableFrames = (sampleCount - firstFrameStart) / frameSamples; return static_cast(std::min( availableFrames / static_cast(parameters.framesPerSuperframe), static_cast(std::numeric_limits::max()) )); } bool DRMReceiver::decodeSDC( const std::complex* samples, std::size_t sampleCount, int sampleRate, const FACAcquisitionResult& fac, SDCData& sdc, int maximumAttempts, std::string* error, std::vector* resultBits ) { sdc = SDCData(); if (error) { error->clear(); } if (resultBits) { resultBits->clear(); } if (!samples || sampleRate <= 0 || maximumAttempts <= 0 || !fac.valid || fac.facBlocks.empty()) { if (error) { *error = "Invalid DRM SDC receiver input"; } return false; } const Mode mode = fac.coarse.mode; const int sdcMode = fac.facBlocks.front().sdcMode; if (!SDCDecoder::supports(mode, sdcMode)) { if (error) { *error = "Unsupported DRM SDC parameters"; } return false; } const int firstFrame = firstTransmissionFrame(fac); if (firstFrame < 0) { if (error) { *error = "No first transmission frame in FAC sequence"; } return false; } const ModeParameters& parameters = Parameters::forMode(mode); const int symbolSamples = parameters.symbolSamples(sampleRate); const std::size_t frameSamples = static_cast( parameters.symbolsPerFrame * symbolSamples ); const std::size_t frameStart = fac.frameStartOffsetSamples + static_cast(firstFrame) * frameSamples; const std::size_t superframeSamples = static_cast( parameters.framesPerSuperframe ) * frameSamples; std::vector combined; std::vector previousBits; int minimumHammingDistance = -1; // The AFS cycle is complete after that many valid blocks, not superframes: // a lost block leaves its part of the cycle still to be received. int validBlocks = 0; for (int superframe = 0; superframe < maximumAttempts; ++superframe) { const std::size_t candidateStart = frameStart + superframeSamples * static_cast(superframe); bool hasPreviousFrame = candidateStart >= frameSamples; const std::size_t contextStart = hasPreviousFrame ? candidateStart - frameSamples : candidateStart; const int contextFrameCount = hasPreviousFrame ? 3 : 2; std::vector>>> spectra; if (!demodulateFrames( samples, sampleCount, sampleRate, mode, contextStart, contextFrameCount, fac.occupancy, hasPreviousFrame ? parameters.framesPerSuperframe - 1 : 0, fac.integerCarrierOffset, fac.coarse.fractionalCarrierOffsetHz, fac.spectralInversion, spectra)) { continue; } // The previous frame is time-interpolation context for the SDC symbols // at the start of frame 0 only if its pilots continue into frame 0 as // frame 0's do into frame 1 (a recording can slip between superframes; // see decodeMSC). Otherwise decode from the superframe's frames alone. if (hasPreviousFrame && spectra.size() == 3U) { const FrameContinuity reference = frameContinuity(mode, fac.occupancy, fac.integerCarrierOffset, sampleRate, spectra[1], 0, spectra[2], 1); const FrameContinuity edge = frameContinuity(mode, fac.occupancy, fac.integerCarrierOffset, sampleRate, spectra[0], parameters.framesPerSuperframe - 1, spectra[1], 0); // Without a valid reference continuity is not shown, as in decodeMSC. if (!reference.valid || !edge.valid || edge.coherence < EdgeFrameCoherence * reference.coherence || std::abs(edge.shiftSamples - reference.shiftSamples) > EdgeFrameShiftSamples * referenceRateScale(mode, sampleRate)) { spectra.erase(spectra.begin()); hasPreviousFrame = false; } } const int targetFrame = hasPreviousFrame ? 1 : 0; const int firstFramePhase = hasPreviousFrame ? parameters.framesPerSuperframe - 1 : 0; std::vector equalized; // The time/frequency estimator resolves echoes the per-symbol pilot // spacing cannot; the per-symbol one remains for mode E without long // echoes (the context decides) and as fallback. ChannelEstimationContext estimation; if (!estimation.prepare(mode, fac.occupancy, firstFramePhase, fac.integerCarrierOffset, spectra)) { continue; } if (!estimation.estimateFrameWiener(targetFrame, equalized) && !estimation.estimateFrame(targetFrame, equalized)) { continue; } std::vector decodedBits; SDCData block; if (SDCDecoder::decode( mode, fac.occupancy, sdcMode, equalized, block, &decodedBits, error)) { if (resultBits) { *resultBits = decodedBits; } if (error) { error->clear(); } const int previousAFSIndex = sdc.valid ? sdc.afsIndex : -1; // A held (unconfirmed) block does not count towards the cycle. if (SDCParser::mergeBlock(sdc, block)) { validBlocks = sdc.afsIndex == previousAFSIndex ? validBlocks + 1 : 1; } const int cycleLength = std::max(1, sdc.afsIndex + 1); if (sdc.multiplex.present && validBlocks >= cycleLength) { return true; } combined.clear(); previousBits.clear(); continue; } if (resultBits) { *resultBits = decodedBits; } if (!previousBits.empty() && previousBits.size() == decodedBits.size()) { const int distance = static_cast(std::inner_product( previousBits.begin(), previousBits.end(), decodedBits.begin(), 0, std::plus(), std::not_equal_to() )); minimumHammingDistance = minimumHammingDistance < 0 ? distance : std::min(minimumHammingDistance, distance); } previousBits = std::move(decodedBits); if (combined.empty()) { combined = equalized; for (EqualizedSymbol& symbol : combined) { for (std::size_t i = 0; i < symbol.channel.size(); ++i) { symbol.channel[i] = { std::sqrt(std::norm(symbol.channel[i])), 0.0f }; } } } else if (combined.size() == equalized.size()) { bool compatible = true; for (std::size_t symbolIndex = 0; compatible && symbolIndex < combined.size(); ++symbolIndex) { EqualizedSymbol& destination = combined[symbolIndex]; const EqualizedSymbol& source = equalized[symbolIndex]; compatible = destination.minimumCarrier == source.minimumCarrier && destination.maximumCarrier == source.maximumCarrier && destination.cells.size() == source.cells.size() && destination.channel.size() == source.channel.size(); for (std::size_t i = 0; compatible && i < destination.cells.size(); ++i) { const float accumulatedWeight = std::norm( destination.channel[i] ); const float sourceWeight = std::norm(source.channel[i]); const float totalWeight = accumulatedWeight + sourceWeight; if (totalWeight <= 1.0e-20f) { continue; } destination.cells[i] = ( accumulatedWeight * destination.cells[i] + sourceWeight * source.cells[i] ) / totalWeight; destination.channel[i] = { std::sqrt(totalWeight), 0.0f }; } } if (!compatible) { combined.clear(); } } if (superframe > 0 && !combined.empty()) { std::vector combinedBits; SDCData combinedBlock; if (SDCDecoder::decode( mode, fac.occupancy, sdcMode, combined, combinedBlock, &combinedBits, error)) { if (resultBits) { *resultBits = combinedBits; } if (error) { error->clear(); } const int previousAFSIndex = sdc.valid ? sdc.afsIndex : -1; // A held (unconfirmed) block does not count towards the cycle. if (SDCParser::mergeBlock(sdc, combinedBlock)) { validBlocks = sdc.afsIndex == previousAFSIndex ? validBlocks + 1 : 1; } const int cycleLength = std::max(1, sdc.afsIndex + 1); if (sdc.multiplex.present && validBlocks >= cycleLength) { return true; } combined.clear(); previousBits.clear(); } } } if (sdc.valid) { if (error) { error->clear(); } return true; } if (error) { if (error->empty()) { *error = "No CRC-valid DRM SDC block found"; } if (minimumHammingDistance >= 0) { *error += " (minimum repeated-block Hamming distance " + std::to_string(minimumHammingDistance) + ")"; } } return false; } bool DRMReceiver::decodeMSC( const std::complex* samples, std::size_t sampleCount, int sampleRate, const FACAcquisitionResult& fac, const SDCData& sdc, ReceiverMSCReport& report, std::int64_t selectedServiceIdentifier, int superframeCount, const PCMCallback& pcmCallback, std::string* error, DRMTextMessageDecoder* textMessageDecoder, DRMAudioDecoder* persistentAudioDecoder, MSCCellDeinterleaver* persistentCellDeinterleaver, ModeEAudioSuperframeAssembler* persistentModeEAudioAssembler, std::vector>* decodedFrames, XHEAACSuperframeParser* persistentXHEAudioParser, bool erasedTransmission, const FACServiceCache* serviceCache, SampleClockState* sampleClock, CarrierNoiseHistory* carrierNoise, DRMSlideshowDecoder* slideshowDecoder, DRMJournalineDecoder* journalineDecoder, DRMWebsiteDecoder* websiteDecoder, DRMSPIDecoder* spiDecoder ) { report = ReceiverMSCReport(); if (error) { error->clear(); } if (decodedFrames) { decodedFrames->clear(); } if (!samples || sampleRate <= 0 || superframeCount < 0 || !fac.valid || fac.facBlocks.empty() || !sdc.multiplex.present) { if (error) { *error = "Missing FAC or SDC configuration for DRM MSC"; } return false; } const Mode mode = fac.coarse.mode; const FACData& channel = fac.facBlocks.front(); const bool unequalProtection = std::any_of( sdc.multiplex.streams.begin(), sdc.multiplex.streams.end(), [](const SDCStreamDescription& stream) { return stream.partALengthBytes != 0; } ); if (!MSCChannelDecoder::supports(mode, channel.mscMode, unequalProtection)) { if (error) { *error = "Unsupported DRM MSC profile"; } return false; } const int firstFrame = firstTransmissionFrame(fac); if (firstFrame < 0) { if (error) { *error = "No first transmission frame in FAC sequence"; } return false; } const ModeParameters& parameters = Parameters::forMode(mode); const int symbolSamples = parameters.symbolSamples(sampleRate); const std::size_t frameSamples = static_cast(parameters.symbolsPerFrame) * static_cast(symbolSamples); const std::size_t firstFrameStart = fac.frameStartOffsetSamples + static_cast(firstFrame) * frameSamples; const int availableSuperframes = maximumCompleteSuperframes( sampleCount, sampleRate, fac ); const int effectiveSuperframeCount = superframeCount == 0 ? availableSuperframes : superframeCount; if (effectiveSuperframeCount <= 0) { if (error) { *error = "No complete DRM transmission superframe available"; } return false; } // Decoding holds every frame's spectra at once; bound a single call so a // whole-file span cannot overflow the frame count or exhaust memory. if (effectiveSuperframeCount > MaximumSuperframesPerCall) { if (error) { *error = "Too many DRM superframes requested in one MSC decode"; } return false; } const int totalFrames = effectiveSuperframeCount * parameters.framesPerSuperframe; const std::size_t requiredSamples = firstFrameStart + static_cast(totalFrames) * frameSamples; if (requiredSamples > sampleCount) { if (error) { *error = "Insufficient samples for DRM MSC interleaver fill"; } return false; } std::vector>>> spectra; double sampleClockErrorPPM = 0.0; if (!erasedTransmission && !demodulateFrames( samples, sampleCount, sampleRate, mode, firstFrameStart, totalFrames, fac.occupancy, 0, fac.integerCarrierOffset, fac.coarse.fractionalCarrierOffsetHz, fac.spectralInversion, spectra, &sampleClockErrorPPM, sampleClock)) { if (error) { *error = "DRM MSC OFDM demodulation failed"; } return false; } report.sampleClockErrorPPM = erasedTransmission && sampleClock && sampleClock->haveDrift ? sampleClock->driftPerFrame * 1.0e6 / static_cast(frameSamples) : sampleClockErrorPPM; std::unique_ptr ownedAudioDecoder; if (!persistentAudioDecoder) { ownedAudioDecoder = DRMAudioDecoder::create(); persistentAudioDecoder = ownedAudioDecoder.get(); } const AudioDecoderCapabilities capabilities = persistentAudioDecoder->capabilities(); const SDCAudioInformation* selectedAudio = nullptr; const FACService* selectedDataService = nullptr; const auto serviceForShortId = [&fac, serviceCache](int shortId) -> const FACService* { if (serviceCache) { return serviceCache->findShortIdentifier(shortId); } for (const FACData& block : fac.facBlocks) { for (const FACService& service : block.services) { if (service.shortIdentifier == shortId) { return &service; } } } return nullptr; }; const auto serviceForAudio = [&serviceForShortId](const SDCAudioInformation& audio) { return serviceForShortId(audio.shortId); }; if (selectedServiceIdentifier >= 0) { const FACService* facService = serviceCache ? serviceCache->findIdentifier(static_cast(selectedServiceIdentifier)) : findFACService(fac, selectedServiceIdentifier); if (!facService) { report.audioError = "Selected DRM service identifier is absent"; } else { const auto found = std::find_if( sdc.audio.begin(), sdc.audio.end(), [facService]( const SDCAudioInformation& audio) { return audio.shortId == facService->shortIdentifier; } ); // The FAC says whether it is a data service: an audio descriptor // left from an earlier configuration does not make it audio. if (facService->dataService) { selectedDataService = facService; } else if (found != sdc.audio.end()) { selectedAudio = &*found; } else { report.audioError = "Selected DRM audio descriptor is unavailable"; } } } else { const auto audioService = [&serviceForAudio](const SDCAudioInformation& audio) { const FACService* service = serviceForAudio(audio); return service && !service->dataService; }; const auto supported = std::find_if( sdc.audio.begin(), sdc.audio.end(), [&capabilities, &serviceForAudio, &audioService]( const SDCAudioInformation& audio) { return audioService(audio) && !serviceForAudio(audio)->audioConditionalAccess && audioCodingSupported(capabilities, audio); } ); // Audio that this receiver could decode with the codec: AAC or // xHE-AAC without conditional access. Selecting it without its codec // reports the codec as unavailable. const auto decodable = std::find_if( sdc.audio.begin(), sdc.audio.end(), [&serviceForAudio, &audioService](const SDCAudioInformation& audio) { return audioService(audio) && !serviceForAudio(audio)->audioConditionalAccess && ((audio.audioCoding == 0) || (audio.audioCoding == 3)); } ); if (supported != sdc.audio.end()) { selectedAudio = &*supported; } else if (decodable != sdc.audio.end()) { selectedAudio = &*decodable; } else { // Without audio that could be decoded, the first data service with // a slideshow or website for (const SDCDataApplication& application : sdc.dataApplications) { const FACService* service = serviceForShortId(application.shortId); if (service && service->dataService && !service->dataConditionalAccess && (DRMSlideshowDecoder::find(sdc, application.shortId) || DRMWebsiteDecoder::find(sdc, application.shortId))) { selectedDataService = service; break; } } // Else the first audio service, to report why it cannot be played: // one the FAC has not announced yet, never a data service's // descriptor left from an earlier configuration const auto first = std::find_if(sdc.audio.begin(), sdc.audio.end(), audioService); const auto unannounced = std::find_if(sdc.audio.begin(), sdc.audio.end(), [&serviceForAudio](const SDCAudioInformation& audio) { return !serviceForAudio(audio); }); if (!selectedDataService) { selectedAudio = first != sdc.audio.end() ? &*first : (unannounced != sdc.audio.end() ? &*unannounced : nullptr); } } } bool decodeAudio = false; bool parseAudio = false; if (selectedAudio) { const FACService* facService = serviceForAudio(*selectedAudio); if (facService) { report.selectedServiceIdentifier = facService->serviceIdentifier; } report.selectedShortId = selectedAudio->shortId; report.selectedStreamId = selectedAudio->streamId; report.audioCodecAvailable = audioCodingSupported(capabilities, *selectedAudio); parseAudio = selectedAudio->audioCoding == 0 || selectedAudio->audioCoding == 3; if (!facService) { parseAudio = false; report.audioError = "Selected DRM audio descriptor has no current FAC service"; } else if (facService->audioConditionalAccess) { parseAudio = false; report.audioError = "DRM conditional-access audio is not supported"; } else if (!parseAudio) { report.audioError = "DRM audio coding is not supported (AAC and xHE-AAC only)"; } else if (!report.audioCodecAvailable) { report.audioError = selectedAudio->audioCoding == 3 ? "DRM xHE-AAC codec is unavailable" : "DRM AAC codec is unavailable"; } else { decodeAudio = persistentAudioDecoder->configure(*selectedAudio, &report.audioError); if (!decodeAudio && report.audioError.empty()) { report.audioError = "DRM audio codec rejected the configuration"; } } } else if (selectedDataService) { report.selectedServiceIdentifier = selectedDataService->serviceIdentifier; report.selectedShortId = selectedDataService->shortIdentifier; report.dataService = true; } else if (report.audioError.empty()) { report.audioError = "No DRM audio descriptor is available"; } // The selected service's slideshow and website, decoded from the same // multiplex frames as its audio (not for conditional-access services). const SDCDataApplication* slideshow = nullptr; const SDCDataApplication* website = nullptr; const FACService* dataFACService = selectedAudio ? serviceForAudio(*selectedAudio) : selectedDataService; // Another service's data and text go before this one's are decoded (not // while the selection is unknown, as when the SDC is rebuilt after a // lost lock) if (dataFACService) { const bool slideshowMoved = slideshowDecoder && slideshowDecoder->setService(dataFACService->serviceIdentifier); const bool websiteMoved = websiteDecoder && websiteDecoder->setService(dataFACService->serviceIdentifier); report.serviceDataReset = slideshowMoved || websiteMoved; report.textMessageReset = textMessageDecoder && textMessageDecoder->setService(dataFACService->serviceIdentifier); } if (dataFACService && !dataFACService->dataConditionalAccess) { if (slideshowDecoder) { slideshow = DRMSlideshowDecoder::find(sdc, dataFACService->shortIdentifier); } if (websiteDecoder) { website = DRMWebsiteDecoder::find(sdc, dataFACService->shortIdentifier); } } report.slideshowPresent = slideshow != nullptr; report.websitePresent = website != nullptr; const auto deliverPCM = [&](const PCMFrame& pcm) { if (pcm.samples.empty()) { return; } if (pcm.concealed) { ++report.concealedPCMFrames; } else { ++report.decodedPCMFrames; } if (pcmCallback) { pcmCallback(pcm); } }; const auto concealFrame = [&]() { if (!decodeAudio) { return; } PCMFrame pcm; std::string concealError; if (persistentAudioDecoder->conceal(pcm, &concealError)) { pcm.concealed = true; deliverPCM(pcm); } }; // What xHE concealment gave beyond the superframes lost, carried by the // caller's parser between calls double localConcealedSurplus = 0.0; double& concealedSurplus = persistentXHEAudioParser ? persistentXHEAudioParser->concealedSurplusSeconds : localConcealedSurplus; const auto concealAACSuperframe = [&]() { if (!selectedAudio || !decodeAudio) { return; } const int frames = AACSuperframeParser::frameCount(mode, *selectedAudio); if (frames >= 0) { for (int i = 0; i < frames; ++i) { concealFrame(); } return; } // xHE-AAC: the number of access units varies, so conceal the audio // superframe's duration (400 ms, 200 ms in mode E), less what earlier // losses gave beyond theirs const double duration = (mode == Mode::E ? 0.2 : 0.4) - concealedSurplus; double concealed = 0.0; for (int i = 0; (i < 64) && (concealed < duration - 1.0e-6); ++i) { PCMFrame pcm; std::string concealError; if (!persistentAudioDecoder->conceal(pcm, &concealError) || pcm.samples.empty() || (pcm.channels <= 0) || (pcm.sampleRate <= 0)) { break; } pcm.concealed = true; concealed += static_cast(pcm.samples.size()) / (pcm.channels * pcm.sampleRate); deliverPCM(pcm); } concealedSurplus = std::max(0.0, concealed - duration); }; std::size_t signalledBytes = 0; std::size_t partABytes = 0; for (const SDCStreamDescription& stream : sdc.multiplex.streams) { partABytes += static_cast(stream.partALengthBytes); signalledBytes += static_cast( stream.partALengthBytes + stream.partBLengthBytes ); } const MSCProtectionParameters protection { sdc.multiplex.protectionLevelA, sdc.multiplex.protectionLevelB, partABytes }; std::vector transmissionFrames( static_cast(parameters.framesPerSuperframe) ); std::vector pilotErrors; // this superframe's, for weightForErrorFloor CarrierNoiseHistory localCarrierNoise; // kept across this call's superframes without a caller's CarrierNoiseHistory& noiseHistory = carrierNoise ? *carrierNoise : localCarrierNoise; std::unique_ptr ownedCellDeinterleaver; if (!persistentCellDeinterleaver) { ownedCellDeinterleaver = std::make_unique( mode, !channel.shortInterleaving ); persistentCellDeinterleaver = ownedCellDeinterleaver.get(); } ModeEAudioSuperframeAssembler localModeEAudioAssembler; ModeEAudioSuperframeAssembler& modeEAudioAssembler = persistentModeEAudioAssembler ? *persistentModeEAudioAssembler : localModeEAudioAssembler; XHEAACSuperframeParser localXHEAudioParser; XHEAACSuperframeParser& xheAudioParser = persistentXHEAudioParser ? *persistentXHEAudioParser : localXHEAudioParser; DRMTextMessageDecoder localTextDecoder; DRMTextMessageDecoder& textDecoder = textMessageDecoder ? *textMessageDecoder : localTextDecoder; double merReferencePower = 0.0; double merErrorPower = 0.0; std::size_t merCellCount = 0; // Every frame is equalized from the same window of pilot estimates. One // frame either side, where the input holds it, gives the time // interpolation pilots beyond the superframe's edges, where it would // otherwise extrapolate from one side. Those frames are demodulated // without steering the sample clock (it stays measured on the decoded // frames); every frame's spectra share the nominal window's phase // reference. A frame is used only if its pilots continue into the // superframe's as the superframe's own frames do into each other: a // recording can slip samples between superframes, which each // superframe's fresh timing absorbs but interpolation across would not. int leadingFrames = 0; // Not in mode E: its per-symbol interpolation smooths over three symbols // either side, and the mode E sweeps showed no gain. if (!erasedTransmission && mode != Mode::E && totalFrames >= 2) { const int lastPhase = parameters.framesPerSuperframe - 1; const double shiftTolerance = EdgeFrameShiftSamples * referenceRateScale(mode, sampleRate); std::vector coherences; std::vector shifts; for (int frame = 0; frame + 1 < totalFrames; ++frame) { const FrameContinuity continuity = frameContinuity(mode, fac.occupancy, fac.integerCarrierOffset, sampleRate, spectra[static_cast(frame)], frame % parameters.framesPerSuperframe, spectra[static_cast(frame + 1)], (frame + 1) % parameters.framesPerSuperframe); if (!continuity.valid) { continue; } coherences.push_back(continuity.coherence); shifts.push_back(continuity.shiftSamples); } // A superframe whose own frames slip is not extended either. With one // superframe (two frame pairs in A-D) the "median" is the larger value. if (!coherences.empty()) { const auto median = [](std::vector values) { const auto middle = values.begin() + static_cast(values.size() / 2U); std::nth_element(values.begin(), middle, values.end()); return *middle; }; const double referenceCoherence = median(coherences); const double referenceShift = median(shifts); const auto continuous = [&](const FrameContinuity& continuity) { return continuity.valid && continuity.coherence >= EdgeFrameCoherence * referenceCoherence && std::abs(continuity.shiftSamples - referenceShift) <= shiftTolerance; }; std::vector>>> edge; const bool steady = std::all_of(shifts.begin(), shifts.end(), [referenceShift, shiftTolerance](double shift) { return std::abs(shift - referenceShift) <= shiftTolerance; }); if (steady && firstFrameStart >= frameSamples && demodulateFrames( samples, sampleCount, sampleRate, mode, firstFrameStart - frameSamples, 1, fac.occupancy, lastPhase, fac.integerCarrierOffset, fac.coarse.fractionalCarrierOffsetHz, fac.spectralInversion, edge) && continuous(frameContinuity(mode, fac.occupancy, fac.integerCarrierOffset, sampleRate, edge.front(), lastPhase, spectra.front(), 0))) { spectra.insert(spectra.begin(), std::move(edge.front())); leadingFrames = 1; } if (steady && demodulateFrames( samples, sampleCount, sampleRate, mode, requiredSamples, 1, fac.occupancy, 0, fac.integerCarrierOffset, fac.coarse.fractionalCarrierOffsetHz, fac.spectralInversion, edge) && continuous(frameContinuity(mode, fac.occupancy, fac.integerCarrierOffset, sampleRate, spectra.back(), lastPhase, edge.front(), 0))) { spectra.push_back(std::move(edge.front())); } } } ChannelEstimationContext estimation; const bool estimationPrepared = !erasedTransmission && estimation.prepare( mode, fac.occupancy, leadingFrames > 0 ? parameters.framesPerSuperframe - 1 : 0, fac.integerCarrierOffset, spectra ); for (int frame = 0; frame < totalFrames; ++frame) { const int framePhase = frame % parameters.framesPerSuperframe; if (erasedTransmission) { auto& erased = transmissionFrames[static_cast(framePhase)]; erased.frameInSuperframe = framePhase; const auto count = CellMap::mscCells(mode, fac.occupancy, framePhase).size(); erased.cells.assign(count, std::complex()); erased.reliabilities.assign(count, 0.0f); } else { std::vector equalized; bool estimated = estimationPrepared && estimation.estimateFrameWiener(frame + leadingFrames, equalized); if (!estimated) { estimated = estimationPrepared && estimation.estimateFrame(frame + leadingFrames, equalized, 3); } if (!estimated) { if (error) { *error = "DRM MSC channel estimation failed"; } return false; } if (!MSCExtractor::extract( mode, fac.occupancy, framePhase, equalized, transmissionFrames[static_cast(framePhase)], error)) { return false; } for (const EqualizedSymbol& symbol : equalized) { pilotErrors.insert(pilotErrors.end(), symbol.pilotErrors.begin(), symbol.pilotErrors.end()); } } if (framePhase != parameters.framesPerSuperframe - 1) { continue; } if (!erasedTransmission) { // The carrier noise is measured on the floor-weighted reliabilities: // each carrier is judged by the error it adds to the metrics the // decoder uses (measured on |H| itself, Kuwait 10:02 decoded 11 // frames fewer and Kuwait 11:19 9 fewer). const SpectrumParameters* spectrum = Parameters::forSpectrum(mode, fac.occupancy); weightForErrorFloor(transmissionFrames, pilotErrors, noisyCarriers(mode, fac.occupancy, channel.mscMode, noiseHistory), spectrum ? spectrum->minimumCarrier : 0); weightForCarrierNoise(mode, fac.occupancy, channel.mscMode, transmissionFrames, noiseHistory); } else { ageCarrierNoise(noiseHistory); } pilotErrors.clear(); MSCSuperframeCells transmissionSuperframe; if (!MSCSuperframeAssembler::assemble( mode, fac.occupancy, transmissionFrames, transmissionSuperframe, error)) { return false; } std::vector transmittedMultiplexFrames; if (!MSCMultiplexFrameSplitter::split( mode, fac.occupancy, transmissionSuperframe, transmittedMultiplexFrames, error)) { return false; } for (const MSCMultiplexFrameCells& transmitted : transmittedMultiplexFrames) { MSCMultiplexFrameCells deinterleaved; bool ready = false; if (!persistentCellDeinterleaver->push( transmitted, deinterleaved, ready, error)) { return false; } if (!ready) { continue; } report.mscReady = true; accumulateDecisionDirectedMER( mode, channel.mscMode, deinterleaved, merReferencePower, merErrorPower, merCellCount ); // A lost frame breaks the data components' packet sequences: // their partial data units go, completed objects stay const auto lostDataFrame = [&]() { if (journalineDecoder) { journalineDecoder->frameLost(); } if (spiDecoder) { spiDecoder->frameLost(); } if (slideshowDecoder) { slideshowDecoder->frameLost(); } if (websiteDecoder) { websiteDecoder->frameLost(); } }; const auto lostMultiplexFrame = [&]() { modeEAudioAssembler.reset(); xheAudioParser.reset(); if (mode != Mode::E || (deinterleaved.frameInSuperframe & 1)) { ++report.invalidAudioSuperframes; concealAACSuperframe(); } }; if (std::none_of(deinterleaved.reliabilities.begin(), deinterleaved.reliabilities.end(), [](float reliability) { return reliability > 0.0f; })) { ++report.invalidMultiplexFrames; lostDataFrame(); if (parseAudio) { lostMultiplexFrame(); } continue; } MSCDecodedMultiplexFrame decoded; if (!MSCChannelDecoder::decode( mode, fac.occupancy, channel.mscMode, protection, deinterleaved, decoded, error)) { return false; } if (decodedFrames) { decodedFrames->push_back(decoded.bits); } // The padding after the signalled streams is zero when sent. It ends // the weakest MLC level, so a residual error confined to it would, // if it rejected the frame, drop audio whose own CRCs pass: reject // only a gross failure (over an eighth of the padding bits set). const std::size_t payloadBits = 8U * signalledBytes; const auto paddingErrors = payloadBits > decoded.bits.size() ? 0 : std::count_if(decoded.bits.begin() + static_cast(payloadBits), decoded.bits.end(), [](std::uint8_t bit) { return bit != 0U; }); const std::size_t paddingBits = payloadBits > decoded.bits.size() ? 0U : decoded.bits.size() - payloadBits; if (payloadBits > decoded.bits.size() || static_cast(paddingErrors) * 8U > std::max(paddingBits, 8U)) { ++report.invalidMultiplexFrames; lostDataFrame(); if (parseAudio) { lostMultiplexFrame(); } continue; } std::vector streams; if (!MSCMultiplexParser::extractStreams( decoded, sdc.multiplex, streams, error)) { ++report.invalidMultiplexFrames; lostDataFrame(); if (parseAudio) { lostMultiplexFrame(); } continue; } ++report.decodedMultiplexFrames; if (journalineDecoder && journalineDecoder->push(sdc, streams)) { report.journalineUpdated = true; } if (spiDecoder && spiDecoder->push(sdc, streams)) { report.spiUpdated = true; } if (slideshow) { const auto dataStream = std::find_if(streams.begin(), streams.end(), [slideshow](const MSCLogicalStreamFrame& stream) { return stream.streamId == slideshow->streamId; }); if (dataStream != streams.end()) { std::vector bytes = dataStream->partA; bytes.insert(bytes.end(), dataStream->partB.begin(), dataStream->partB.end()); slideshowDecoder->push(*slideshow, bytes, report.slideshowObjects); } report.slideshowValidPackets = slideshowDecoder->validPackets(); report.slideshowInvalidPackets = slideshowDecoder->invalidPackets(); } if (website) { const auto dataStream = std::find_if(streams.begin(), streams.end(), [website](const MSCLogicalStreamFrame& stream) { return stream.streamId == website->streamId; }); if (dataStream != streams.end()) { std::vector bytes = dataStream->partA; bytes.insert(bytes.end(), dataStream->partB.begin(), dataStream->partB.end()); report.websiteUpdated = websiteDecoder->push(*website, bytes) || report.websiteUpdated; } report.websiteValidPackets = websiteDecoder->validPackets(); report.websiteInvalidPackets = websiteDecoder->invalidPackets(); } if (!parseAudio) { continue; } const auto selectedStream = std::find_if( streams.begin(), streams.end(), [selectedAudio]( const MSCLogicalStreamFrame& stream) { return stream.streamId == selectedAudio->streamId; } ); // The following are service/data errors, not RF errors: report // them, conceal the audio, and keep RF, MSC and interleaver state. if (selectedStream == streams.end()) { report.audioError = "DRM audio stream is absent from multiplex frame"; lostMultiplexFrame(); continue; } std::vector logicalAudio = selectedStream->partA; logicalAudio.insert( logicalAudio.end(), selectedStream->partB.begin(), selectedStream->partB.end() ); if (selectedAudio->text) { if (logicalAudio.size() < 4U) { report.audioError = "DRM audio logical frame is shorter than its text field"; lostMultiplexFrame(); continue; } const std::size_t textOffset = logicalAudio.size() - 4U; const std::array textPiece { logicalAudio[textOffset], logicalAudio[textOffset + 1U], logicalAudio[textOffset + 2U], logicalAudio[textOffset + 3U] }; DRMTextMessage textMessage; bool textReady = false; std::string textError; if (!textDecoder.push( textPiece, textMessage, textReady, &textError)) { ++report.invalidTextSegments; } else if (textReady) { report.textMessageUpdated = true; report.clearTextMessage = textMessage.clearDisplay; report.textMessage = std::move(textMessage.utf8); } logicalAudio.resize(logicalAudio.size() - 4U); } // Part A leads the logical frame; the text field, if any, ends it. const std::size_t logicalPartABytes = std::min(selectedStream->partA.size(), logicalAudio.size()); std::vector audioSuperframeBytes; std::size_t audioPartABytes = logicalPartABytes; bool audioReady = false; if (mode == Mode::E) { std::string assemblyError; audioPartABytes = 2U * logicalPartABytes; if (!modeEAudioAssembler.push( deinterleaved.frameInSuperframe, logicalAudio, audioSuperframeBytes, audioReady, &assemblyError, logicalPartABytes)) { report.audioError = assemblyError; lostMultiplexFrame(); continue; } } else { audioSuperframeBytes = std::move(logicalAudio); audioReady = true; } if (!audioReady) { if (mode == Mode::E && (deinterleaved.frameInSuperframe & 1)) { ++report.invalidAudioSuperframes; xheAudioParser.reset(); concealAACSuperframe(); } continue; } AACSuperframe audioSuperframe; std::string audioFrameError; const bool parsedAudio = selectedAudio->audioCoding == 0 ? AACSuperframeParser::parse( mode, *selectedAudio, audioSuperframeBytes, audioSuperframe, &audioFrameError, audioPartABytes) : selectedAudio->audioCoding == 3 ? xheAudioParser.push( audioSuperframeBytes, audioSuperframe, &audioFrameError) : false; if (!parsedAudio) { ++report.invalidAudioSuperframes; xheAudioParser.reset(); concealAACSuperframe(); continue; } if (audioSuperframe.invalidFrameCount > 0) { ++report.invalidAudioSuperframes; } ++report.parsedAudioSuperframes; if (!decodeAudio) { continue; } for (const int slot : audioSuperframe.codecFrameSequence) { if (slot < 0) { concealFrame(); continue; } const auto& codecFrame = audioSuperframe.codecFrames[static_cast(slot)]; PCMFrame pcm; std::string codecError; if (!persistentAudioDecoder->decode(codecFrame, pcm, &codecError)) { concealFrame(); continue; } deliverPCM(pcm); } } } report.processedSuperframes = effectiveSuperframeCount; report.consumedSamples = requiredSamples; if (merCellCount > 0 && merReferencePower > 1.0e-20) { report.mscMERAvailable = true; report.mscMERDB = 10.0 * std::log10( merReferencePower / std::max(merErrorPower, 1.0e-20) ); report.mscMERCellCount = merCellCount; } if (error) { error->clear(); } return true; } } // namespace modemdrm