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.
 
 
 
 
 
 

325 lines
12 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 "drmfac.h"
#include "drmbitutils.h"
#include "drmcellmap.h"
#include "drmconvolutional.h"
#include "drminterleaver.h"
#include <cstddef>
#include <algorithm>
namespace modemdrm
{
namespace
{
// The two supplied 2012 RFmondial DRM+ vectors scramble the FAC tail bits
// (see decode()). decode() removes the scrambled tail exactly, after the
// standard decode fails, when its caller allows it (the receiver does for
// mode E).
std::uint32_t readBits(const std::vector<std::uint8_t>& bits, std::size_t& offset, int count)
{
std::uint32_t value = 0;
for (int i = 0; i < count; ++i) {
value = (value << 1U) | (bits[offset++] & 1U);
}
return value;
}
FACService readService(const std::vector<std::uint8_t>& bits, std::size_t& offset)
{
FACService service;
service.serviceIdentifier = readBits(bits, offset, 24);
service.shortIdentifier = static_cast<int>(readBits(bits, offset, 2));
service.audioConditionalAccess = readBits(bits, offset, 1) != 0;
service.language = static_cast<int>(readBits(bits, offset, 4));
service.dataService = readBits(bits, offset, 1) != 0;
service.descriptor = static_cast<int>(readBits(bits, offset, 5));
service.dataConditionalAccess = readBits(bits, offset, 1) != 0;
readBits(bits, offset, 6); // rfa
return service;
}
} // namespace
int FACData::serviceCount() const
{
// ES 201 980 6.3.4: the audio services in the upper two bits (0 with
// no data services is 4), the data services in the lower two (3 with 3
// audio services is 4 data services)
if (serviceCountCode == 0) {
return 4;
}
if (serviceCountCode == 15) {
return 4;
}
return std::min(4, (serviceCountCode >> 2) + (serviceCountCode & 3));
}
void FACServiceCache::reset()
{
m_services.clear();
m_serviceCountCode = m_reconfigurationIndex = -1;
}
bool FACServiceCache::observe(const FACData& block)
{
const bool firstFrame = block.identity == 0 || block.identity == 3;
const bool invalidated = (m_serviceCountCode >= 0
&& m_serviceCountCode != block.serviceCountCode)
|| (firstFrame && m_reconfigurationIndex > 0 && block.reconfigurationIndex == 0);
if (invalidated) {
m_services.clear();
}
m_serviceCountCode = block.serviceCountCode;
if (firstFrame) {
m_reconfigurationIndex = block.reconfigurationIndex;
}
for (const auto& service : block.services)
{
if (service.shortIdentifier < 0 || service.shortIdentifier > 3) {
continue;
}
auto found = std::find_if(m_services.begin(), m_services.end(),
[&service](const FACService& item) { return item.shortIdentifier == service.shortIdentifier; });
if (found == m_services.end()) {
m_services.push_back(service);
} else {
*found = service;
}
}
return invalidated;
}
const FACService* FACServiceCache::findIdentifier(std::uint32_t identifier) const
{
const auto found = std::find_if(m_services.begin(), m_services.end(),
[identifier](const FACService& item) { return item.serviceIdentifier == identifier; });
return found == m_services.end() ? nullptr : &*found;
}
const FACService* FACServiceCache::findShortIdentifier(int identifier) const
{
const auto found = std::find_if(m_services.begin(), m_services.end(),
[identifier](const FACService& item) { return item.shortIdentifier == identifier; });
return found == m_services.end() ? nullptr : &*found;
}
int FACDecoder::informationBitCount(Mode mode)
{
return mode == Mode::E ? 116 : 72;
}
namespace
{
// The rate-1/4 coded bits contributed by a dispersed tail after the mode E
// FAC's zero information bits: the encoder starts the tail in the zero state.
const std::vector<std::uint8_t>& legacyTailPattern()
{
static const std::vector<std::uint8_t> pattern = [] {
const std::size_t informationBits = static_cast<std::size_t>(FACDecoder::informationBitCount(Mode::E));
std::vector<std::uint8_t> prbs(informationBits + ConvolutionalCode::TailBitCount, 0U);
EnergyDispersal::apply(prbs);
std::vector<std::uint8_t> inputs(informationBits + ConvolutionalCode::TailBitCount, 0U);
std::copy(prbs.begin() + static_cast<std::ptrdiff_t>(informationBits), prbs.end(),
inputs.begin() + static_cast<std::ptrdiff_t>(informationBits));
const std::vector<std::uint8_t> mother = ConvolutionalCode::encodeMother(inputs);
// Rate 1/4 transmits mother-code branches 0 to 3 of every step.
std::vector<std::uint8_t> coded;
for (std::size_t step = 0; step < inputs.size(); ++step)
{
for (std::size_t branch = 0; branch < 4U; ++branch) {
coded.push_back(mother[step * 6U + branch]);
}
}
return coded;
}();
return pattern;
}
} // namespace
bool FACDecoder::decodeBits(
Mode mode,
std::vector<std::uint8_t> bits,
FACData& data
)
{
const int bitCount = informationBitCount(mode);
if (static_cast<int>(bits.size()) != bitCount) {
return false;
}
EnergyDispersal::apply(bits);
const std::size_t payloadBits = mode == Mode::E ? 108U : 64U;
std::vector<std::uint8_t> crcInput(bits.begin(), bits.begin() + static_cast<std::ptrdiff_t>(payloadBits));
if (mode == Mode::E) {
crcInput.insert(crcInput.end(), 4U, 0U);
}
std::size_t crcOffset = payloadBits;
const std::uint8_t transmittedCRC = static_cast<std::uint8_t>(readBits(bits, crcOffset, 8));
const std::uint8_t expectedCRC = CRC::crc8(crcInput.data(), crcInput.size());
if (expectedCRC != transmittedCRC) {
return false;
}
std::size_t offset = 0;
FACData decoded;
decoded.baseLayer = readBits(bits, offset, 1) == 0;
decoded.identity = static_cast<int>(readBits(bits, offset, 2));
decoded.modeE = readBits(bits, offset, 1) != 0;
decoded.occupancy = static_cast<int>(readBits(bits, offset, 3));
decoded.shortInterleaving = readBits(bits, offset, 1) != 0;
decoded.mscMode = static_cast<int>(readBits(bits, offset, 2));
decoded.sdcMode = static_cast<int>(readBits(bits, offset, 1));
decoded.serviceCountCode = static_cast<int>(readBits(bits, offset, 4));
decoded.reconfigurationIndex = static_cast<int>(readBits(bits, offset, 3));
decoded.toggle = readBits(bits, offset, 1) != 0;
// rfu: receivers ignore it (as Dream does), so a later use of it does not
// stop them locking
readBits(bits, offset, 1);
// Validate the signalled mode before it controls the service count. A CRC
// match does not guarantee legal signalling: an A-D block has only one
// service field and must never be parsed as the longer mode-E layout.
if (decoded.modeE != (mode == Mode::E)
|| Parameters::forSpectrum(mode, decoded.occupancy) == nullptr) {
return false;
}
const int serviceParameterCount = mode == Mode::E ? 2 : 1;
decoded.services.reserve(static_cast<std::size_t>(serviceParameterCount));
for (int i = 0; i < serviceParameterCount; ++i) {
decoded.services.push_back(readService(bits, offset));
}
// Only a block that passes every check replaces data.
data = std::move(decoded);
return true;
}
bool FACDecoder::decode(
Mode mode,
const std::vector<EqualizedSymbol>& symbols,
FACData& data,
std::vector<std::uint8_t>* decodedBits,
bool allowLegacyModeETail
)
{
const std::vector<CellPosition>& positions = CellMap::facCells(mode);
std::vector<float> interleavedSoftBits;
interleavedSoftBits.reserve(positions.size() * 2U);
for (const CellPosition& position : positions)
{
if (position.symbol < 0 || static_cast<std::size_t>(position.symbol) >= symbols.size()
|| !symbols[static_cast<std::size_t>(position.symbol)].contains(position.carrier)) {
return false;
}
const EqualizedSymbol& symbol = symbols[static_cast<std::size_t>(position.symbol)];
const std::complex<float>& cell = symbol.cell(position.carrier);
const std::size_t channelIndex = static_cast<std::size_t>(
position.carrier - symbol.minimumCarrier
);
// The equalized constellation has been divided by |H|^2. Restore |H|
// (as the MSC does) in A-D: on real HF, interference and estimation
// errors on strong carriers made |H|^2 trust a few wrong cells over
// the rest (BBC 3955 kHz: 36 failed blocks, none with |H|; Kuwait
// 10:02 39 to 2). The mode E sweeps (deep fades, no interference)
// lose 2% of superframes with |H|; keep |H|^2 there.
const float reliability = channelIndex >= symbol.channel.size() ? 1.0f
: mode == Mode::E ? std::norm(symbol.channel[channelIndex])
: std::abs(symbol.channel[channelIndex]);
interleavedSoftBits.push_back(cell.real() * reliability);
interleavedSoftBits.push_back(cell.imag() * reliability);
}
std::vector<float> softBits = BitInterleaver::deinterleave(interleavedSoftBits, 21);
const std::size_t information = static_cast<std::size_t>(informationBitCount(mode));
const CodeRate rate = mode == Mode::E ? CodeRate::R1_4 : CodeRate::R3_5;
// On failure decodedBits keeps the standard attempt's bits.
const auto attempt = [&](const std::vector<float>& soft, bool first) {
std::vector<std::uint8_t> bits;
if (!ViterbiDecoder::decode(soft, information, rate, bits)) {
return false;
}
std::vector<std::uint8_t> descrambled;
if (decodedBits)
{
descrambled = bits;
EnergyDispersal::apply(descrambled);
}
const bool decoded = decodeBits(mode, std::move(bits), data);
if (decodedBits && (decoded || first)) {
*decodedBits = std::move(descrambled);
}
return decoded;
};
if (attempt(softBits, true)) {
return true;
}
if (mode != Mode::E || !allowLegacyModeETail) {
return false;
}
// Early DRM+ transmitters (the 2012 RFmondial recordings) applied energy
// dispersal to the six tail bits as well, so the code does not end in the
// zero state. The code is linear: remove the scrambled tail's contribution
// by flipping the soft bits it sets, then decode as usual. The CRC is then
// the standard one.
const std::vector<std::uint8_t>& tailPattern = legacyTailPattern();
std::vector<float> legacySoft = softBits;
for (std::size_t i = 0; i < legacySoft.size() && i < tailPattern.size(); ++i)
{
if (tailPattern[i]) {
legacySoft[i] = -legacySoft[i];
}
}
if (attempt(legacySoft, false))
{
data.legacyModeETail = true;
return true;
}
// Such blocks decoded with a zero-terminated trellis instead show a fixed
// CRC syndrome (0x05); accepting it would add a CRC hypothesis per failed
// block for little gain, since the exact tail removal decodes them.
return false;
}
} // namespace modemdrm