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.
1028 lines
32 KiB
1028 lines
32 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 <array> |
|
#include <cmath> |
|
#include <map> |
|
#include <mutex> |
|
#include <tuple> |
|
|
|
#include "dvbt2.h" |
|
#include "dvbt2tables.h" |
|
|
|
namespace dvbt2 { |
|
|
|
const char *toString(GuardInterval guard) |
|
{ |
|
static const char *names[] = {"1/32", "1/16", "1/8", "1/4", "1/128", "19/128", "19/256"}; |
|
return names[(int) guard]; |
|
} |
|
|
|
const char *toString(PilotPattern pattern) |
|
{ |
|
static const char *names[] = {"PP1", "PP2", "PP3", "PP4", "PP5", "PP6", "PP7", "PP8"}; |
|
return names[(int) pattern]; |
|
} |
|
|
|
const char *toString(Constellation constellation) |
|
{ |
|
static const char *names[] = {"QPSK", "16-QAM", "64-QAM", "256-QAM"}; |
|
return names[(int) constellation]; |
|
} |
|
|
|
const char *toString(L1Constellation constellation) |
|
{ |
|
static const char *names[] = {"BPSK", "QPSK", "16-QAM", "64-QAM"}; |
|
return names[(int) constellation]; |
|
} |
|
|
|
const char *toString(CodeRate rate) |
|
{ |
|
static const char *names[] = {"1/2", "3/5", "2/3", "3/4", "4/5", "5/6", "1/3", "2/5", "1/4", "8/9", "9/10", |
|
"13/45", "9/20", "11/20", "26/45", "28/45", "23/36", "25/36", "13/18", "7/9", "90/180", "96/180", "100/180", |
|
"104/180", "116/180", "124/180", "128/180", "132/180", "135/180", "140/180", "154/180", "18/30", "20/30", |
|
"22/30", "11/45", "4/15", "14/45", "7/15", "8/15", "32/45", "2/9", "1/5"}; |
|
return ((int) rate >= 0) && ((int) rate < nbCodeRates) ? names[(int) rate] : "?"; |
|
} |
|
|
|
const char *fftSizeString(int fftSize) |
|
{ |
|
switch (fftSize) |
|
{ |
|
case 1024: return "1K"; |
|
case 2048: return "2K"; |
|
case 4096: return "4K"; |
|
case 8192: return "8K"; |
|
case 16384: return "16K"; |
|
case 32768: return "32K"; |
|
default: return "?"; |
|
} |
|
} |
|
|
|
double sampleRate(int bandwidthHz) |
|
{ |
|
if (bandwidthHz == 1700000) { |
|
return 131e6 / 71.0; |
|
} |
|
|
|
return 8.0 * bandwidthHz / 7.0; |
|
} |
|
|
|
int guardSamples(int fftSize, GuardInterval guard) |
|
{ |
|
switch (guard) |
|
{ |
|
case GuardInterval::G1_32: return fftSize / 32; |
|
case GuardInterval::G1_16: return fftSize / 16; |
|
case GuardInterval::G1_8: return fftSize / 8; |
|
case GuardInterval::G1_4: return fftSize / 4; |
|
case GuardInterval::G1_128: return fftSize / 128; |
|
case GuardInterval::G19_128: return 19 * fftSize / 128; |
|
case GuardInterval::G19_256: return 19 * fftSize / 256; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
bool guardAllowed(int fftSize, GuardInterval guard) |
|
{ |
|
bool newGuard = (guard == GuardInterval::G1_128) || (guard == GuardInterval::G19_128) || (guard == GuardInterval::G19_256); |
|
|
|
switch (fftSize) |
|
{ |
|
case 32768: return guard != GuardInterval::G1_4; |
|
case 16384: |
|
case 8192: return true; |
|
case 4096: |
|
case 2048: return !newGuard; |
|
case 1024: return !newGuard && (guard != GuardInterval::G1_32); |
|
default: return false; |
|
} |
|
} |
|
|
|
int numP2(int fftSize) |
|
{ |
|
switch (fftSize) |
|
{ |
|
case 1024: return 16; |
|
case 2048: return 8; |
|
case 4096: return 4; |
|
case 8192: return 2; |
|
default: return 1; |
|
} |
|
} |
|
|
|
int kMaxNormal(int fftSize) |
|
{ |
|
switch (fftSize) |
|
{ |
|
case 1024: return 852; |
|
case 2048: return 1704; |
|
case 4096: return 3408; |
|
case 8192: return 6816; |
|
case 16384: return 13632; |
|
case 32768: return 27264; |
|
default: return 0; |
|
} |
|
} |
|
|
|
int kExt(int fftSize) |
|
{ |
|
switch (fftSize) |
|
{ |
|
case 8192: return 48; |
|
case 16384: return 144; |
|
case 32768: return 288; |
|
default: return 0; |
|
} |
|
} |
|
|
|
int dx(PilotPattern pattern) |
|
{ |
|
static const int values[] = {3, 6, 6, 12, 12, 24, 24, 6}; |
|
return values[(int) pattern]; |
|
} |
|
|
|
int dy(PilotPattern pattern) |
|
{ |
|
static const int values[] = {4, 2, 4, 2, 4, 2, 4, 16}; |
|
return values[(int) pattern]; |
|
} |
|
|
|
// Table 64: used when time interpolation is needed, i.e. Dx Dy is at least the reciprocal of the guard interval |
|
// fraction, except with PP8 |
|
bool frameClosingSymbol(int fftSize, GuardInterval guard, PilotPattern pattern, bool miso) |
|
{ |
|
if (pattern == PilotPattern::PP8) { |
|
return false; |
|
} |
|
|
|
if (miso) { |
|
return true; |
|
} |
|
|
|
return dx(pattern) * dy(pattern) * guardSamples(fftSize, guard) >= fftSize; |
|
} |
|
|
|
int bitsPerCell(Constellation constellation) |
|
{ |
|
return 2 * ((int) constellation + 1); |
|
} |
|
|
|
int bitsPerCell(L1Constellation constellation) |
|
{ |
|
static const int values[] = {1, 2, 4, 6}; |
|
return values[(int) constellation]; |
|
} |
|
|
|
int nldpc(FECType type) |
|
{ |
|
return type == FECType::Normal ? 64800 : type == FECType::Medium ? 32400 : 16200; |
|
} |
|
|
|
int kldpc(FECType type, CodeRate rate, CodeFamily family) |
|
{ |
|
const bool s2 = family == CodeFamily::S2; |
|
|
|
// The medium FECFRAME's (EN 302 307-2 table 5: VL-SNR's 1/5, 11/45 and 1/3), only S2's |
|
if (type == FECType::Medium) { |
|
return !s2 ? 0 : rate == CodeRate::R1_5 ? 6480 : rate == CodeRate::R11_45 ? 7920 : rate == CodeRate::R1_3 ? 10800 : 0; |
|
} |
|
|
|
// S2X's (EN 302 307-2 tables 4 and 6: Nbch), only in S2's family, each in the frame sizes it has |
|
if (isS2X(rate)) |
|
{ |
|
static const int kNormal[] = {18720, 29160, 35640, 37440, 40320, 41400, 45000, 46800, 50400, 32400, 34560, 36000, |
|
37440, 41760, 44640, 46080, 47520, 48600, 50400, 55440, 38880, 43200, 47520, 0, 0, 0, 0, 0, 0, 14400, 0}; |
|
static const int kShort[] = {0, 0, 0, 9360, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3960, 4320, 5040, 7560, 8640, 11520, 0, 0}; |
|
const int i = (int) rate - (int) CodeRate::R13_45; |
|
return !s2 ? 0 : (type == FECType::Normal ? kNormal : kShort)[i]; |
|
} |
|
|
|
if (type == FECType::Normal) |
|
{ |
|
static const int kT2[] = {32400, 38880, 43200, 48600, 51840, 54000, 0, 0, 0, 0, 0}; |
|
static const int kS2[] = {32400, 38880, 43200, 48600, 51840, 54000, 21600, 25920, 16200, 57600, 58320}; |
|
return (s2 ? kS2 : kT2)[(int) rate]; |
|
} |
|
else |
|
{ |
|
static const int kT2[] = {7200, 9720, 10800, 11880, 12600, 13320, 5400, 6480, 3240, 0, 0}; |
|
static const int kS2[] = {7200, 9720, 10800, 11880, 12600, 13320, 5400, 6480, 3240, 14400, 0}; |
|
return (s2 ? kS2 : kT2)[(int) rate]; |
|
} |
|
} |
|
|
|
int bchT(FECType type, CodeRate rate, CodeFamily family) |
|
{ |
|
if (isS2X(rate) || (type == FECType::Medium)) { |
|
return 12; // Tables 4 to 6 |
|
} |
|
|
|
if (type == FECType::Normal) |
|
{ |
|
if ((family == CodeFamily::S2) && ((rate == CodeRate::R8_9) || (rate == CodeRate::R9_10))) { |
|
return 8; |
|
} |
|
|
|
if ((rate == CodeRate::R2_3) || (rate == CodeRate::R5_6)) { |
|
return 10; |
|
} |
|
} |
|
|
|
return 12; |
|
} |
|
|
|
int kbch(FECType type, CodeRate rate, CodeFamily family) |
|
{ |
|
// Each of the BCH code's t polynomials has the field's degree: 16, 15 (medium) or 14 |
|
return kldpc(type, rate, family) - bchT(type, rate, family) * (type == FECType::Normal ? 16 : type == FECType::Medium ? 15 : 14); |
|
} |
|
|
|
int cellsPerFECBlock(FECType type, Constellation constellation) |
|
{ |
|
return nldpc(type) / bitsPerCell(constellation); |
|
} |
|
|
|
int fftSizeFromS2(int s2, bool& newGuards, bool lite) |
|
{ |
|
static const int sizes[] = {2048, 8192, 4096, 1024, 16384, 32768, 8192, 32768}; |
|
static const int liteSizes[] = {2048, 8192, 4096, 16384, 16384, 0, 8192, 0}; // No 1K or 32K |
|
int field1 = (s2 >> 1) & 7; |
|
newGuards = lite ? (field1 == 3) || (field1 == 6) : field1 >= 6; |
|
return lite ? liteSizes[field1] : sizes[field1]; |
|
} |
|
|
|
int P1Signalling::fftSize() const |
|
{ |
|
if (!isT2()) { |
|
return 0; |
|
} |
|
|
|
bool newGuards; |
|
return fftSizeFromS2(m_s2, newGuards, isT2Lite()); |
|
} |
|
|
|
// Bit fields, MSB first, one bit per byte |
|
|
|
uint32_t L1Pre::getBits(const uint8_t *bits, int& offset, int nb) |
|
{ |
|
uint32_t value = 0; |
|
|
|
for (int i = 0; i < nb; i++) { |
|
value = (value << 1) | (bits[offset + i] & 1); |
|
} |
|
|
|
offset += nb; |
|
return value; |
|
} |
|
|
|
void L1Pre::putBits(std::vector<uint8_t>& bits, uint32_t value, int nb) |
|
{ |
|
for (int i = nb - 1; i >= 0; i--) { |
|
bits.push_back((value >> i) & 1); |
|
} |
|
} |
|
|
|
uint32_t crc32(const uint8_t *bits, int nbBits) |
|
{ |
|
uint32_t crc = 0xffffffff; |
|
|
|
for (int i = 0; i < nbBits; i++) |
|
{ |
|
uint32_t bit = ((crc >> 31) ^ bits[i]) & 1; |
|
crc = (crc << 1) ^ (bit ? 0x04c11db7 : 0); |
|
} |
|
|
|
return crc; |
|
} |
|
|
|
// A byte at a time, as every TS packet's is checked: the CRC of each byte value, from 0 |
|
uint8_t crc8(const uint8_t *bytes, int nbBytes) |
|
{ |
|
static const std::array<uint8_t, 256> table = []() { |
|
std::array<uint8_t, 256> t; |
|
|
|
for (int v = 0; v < 256; v++) |
|
{ |
|
uint8_t crc = (uint8_t) v; |
|
|
|
for (int b = 0; b < 8; b++) { |
|
crc = (uint8_t) ((crc << 1) ^ (crc & 0x80 ? 0xd5 : 0)); |
|
} |
|
|
|
t[v] = crc; |
|
} |
|
|
|
return t; |
|
}(); |
|
uint8_t crc = 0; |
|
|
|
for (int i = 0; i < nbBytes; i++) { |
|
crc = table[crc ^ bytes[i]]; |
|
} |
|
|
|
return crc; |
|
} |
|
|
|
void scramble(uint8_t *bits, int nbBits) |
|
{ |
|
unsigned int st = 0251; // 100101010000000, bit-reversed |
|
|
|
for (int i = 0; i < nbBits; i++) |
|
{ |
|
unsigned int bit = ((st >> 13) ^ (st >> 14)) & 1; |
|
st = (st << 1) | bit; |
|
bits[i] ^= bit; |
|
} |
|
} |
|
|
|
void scrambleBytes(uint8_t *bytes, int nbBytes) |
|
{ |
|
static std::vector<uint8_t> sequence; |
|
static std::once_flag once; |
|
|
|
std::call_once(once, []() { |
|
const int maxBytes = 58192 / 8; // DVB-S2's largest BBFRAME (9/10), T2's 53840 |
|
sequence.resize(maxBytes); |
|
unsigned int st = 0251; |
|
|
|
for (int i = 0; i < maxBytes; i++) |
|
{ |
|
uint8_t out = 0; |
|
|
|
for (int n = 0; n < 8; n++) |
|
{ |
|
unsigned int bit = ((st >> 13) ^ (st >> 14)) & 1; |
|
out = (uint8_t) ((out << 1) | bit); |
|
st = (st << 1) | bit; |
|
} |
|
|
|
sequence[i] = out; |
|
} |
|
}); |
|
|
|
for (int i = 0; i < nbBytes; i++) { |
|
bytes[i] ^= sequence[i]; |
|
} |
|
} |
|
|
|
bool L1Pre::decode(const uint8_t *bits) |
|
{ |
|
int o = 0; |
|
m_type = getBits(bits, o, 8); |
|
m_bwtExt = getBits(bits, o, 1); |
|
m_s1 = getBits(bits, o, 3); |
|
m_s2 = getBits(bits, o, 4); |
|
m_l1RepetitionFlag = getBits(bits, o, 1); |
|
int guard = getBits(bits, o, 3); |
|
m_guard = (GuardInterval) std::min(guard, 6); |
|
m_papr = getBits(bits, o, 4); |
|
int l1Mod = getBits(bits, o, 4); |
|
m_l1Mod = (L1Constellation) std::min(l1Mod, 3); |
|
m_l1Cod = getBits(bits, o, 2); |
|
m_l1FecType = getBits(bits, o, 2); |
|
m_l1PostSize = getBits(bits, o, 18); |
|
m_l1PostInfoSize = getBits(bits, o, 18); |
|
int pattern = getBits(bits, o, 4); |
|
m_pilotPattern = (PilotPattern) std::min(pattern, 7); |
|
m_txIdAvailability = getBits(bits, o, 8); |
|
m_cellId = getBits(bits, o, 16); |
|
m_networkId = getBits(bits, o, 16); |
|
m_t2SystemId = getBits(bits, o, 16); |
|
m_numT2Frames = getBits(bits, o, 8); |
|
m_numDataSymbols = getBits(bits, o, 12); |
|
m_regenFlag = getBits(bits, o, 3); |
|
m_l1PostExtension = getBits(bits, o, 1); |
|
m_numRf = getBits(bits, o, 3); |
|
m_currentRfIdx = getBits(bits, o, 3); |
|
m_t2Version = getBits(bits, o, 4); |
|
m_l1PostScrambled = getBits(bits, o, 1); |
|
m_t2BaseLite = getBits(bits, o, 1); |
|
o += 4; // Reserved |
|
uint32_t crc = getBits(bits, o, 32); |
|
|
|
if (m_t2Version < 2) |
|
{ |
|
m_l1PostScrambled = false; |
|
m_t2BaseLite = false; |
|
} |
|
|
|
return (crc == crc32(bits, size - 32)) && (guard <= 6) && (l1Mod <= 3) && (pattern <= 7); |
|
} |
|
|
|
void L1Pre::encode(uint8_t *bits) const |
|
{ |
|
std::vector<uint8_t> v; |
|
putBits(v, m_type, 8); |
|
putBits(v, m_bwtExt, 1); |
|
putBits(v, m_s1, 3); |
|
putBits(v, m_s2, 4); |
|
putBits(v, m_l1RepetitionFlag, 1); |
|
putBits(v, (int) m_guard, 3); |
|
putBits(v, m_papr, 4); |
|
putBits(v, (int) m_l1Mod, 4); |
|
putBits(v, m_l1Cod, 2); |
|
putBits(v, m_l1FecType, 2); |
|
putBits(v, m_l1PostSize, 18); |
|
putBits(v, m_l1PostInfoSize, 18); |
|
putBits(v, (int) m_pilotPattern, 4); |
|
putBits(v, m_txIdAvailability, 8); |
|
putBits(v, m_cellId, 16); |
|
putBits(v, m_networkId, 16); |
|
putBits(v, m_t2SystemId, 16); |
|
putBits(v, m_numT2Frames, 8); |
|
putBits(v, m_numDataSymbols, 12); |
|
putBits(v, m_regenFlag, 3); |
|
putBits(v, m_l1PostExtension, 1); |
|
putBits(v, m_numRf, 3); |
|
putBits(v, m_currentRfIdx, 3); |
|
putBits(v, m_t2Version, 4); |
|
putBits(v, m_l1PostScrambled, 1); |
|
putBits(v, m_t2BaseLite, 1); |
|
putBits(v, 0, 4); |
|
putBits(v, crc32(v.data(), (int) v.size()), 32); |
|
std::copy(v.begin(), v.end(), bits); |
|
} |
|
|
|
int L1Pre::fftSize() const |
|
{ |
|
bool newGuards; |
|
return fftSizeFromS2(m_s2, newGuards, (m_s1 == (int) PreambleType::T2LiteSISO) || (m_s1 == (int) PreambleType::T2LiteMISO)); |
|
} |
|
|
|
bool L1Post::decode(const uint8_t *bits, const L1Pre& pre) |
|
{ |
|
const int size = pre.m_l1PostInfoSize; |
|
uint32_t crc = 0; |
|
|
|
for (int i = 0; i < 32; i++) { |
|
crc = (crc << 1) | (bits[size + i] & 1); |
|
} |
|
|
|
if ((crc != crc32(bits, size)) || (size < 35)) { |
|
return false; |
|
} |
|
|
|
int o = 0; |
|
m_subSlicesPerFrame = L1Pre::getBits(bits, o, 15); |
|
int numPlp = L1Pre::getBits(bits, o, 8); |
|
m_numAux = L1Pre::getBits(bits, o, 4); |
|
m_auxConfigRfu = L1Pre::getBits(bits, o, 8); |
|
|
|
// The fields' length, from the numbers of loops, must fit: the bits beyond aren't there |
|
const int fields = 35 + 35 * pre.m_numRf + ((pre.m_s2 & 1) ? 34 : 0) + 89 * numPlp + 32 + 32 * m_numAux + 71 + 48 * numPlp; |
|
|
|
if (fields > size) { |
|
return false; |
|
} |
|
|
|
// Code rates, modulations and FEC types reserved for the profile (tables 32 to 34): such a PLP can't be decoded |
|
const bool lite = (pre.m_s1 == (int) PreambleType::T2LiteSISO) || (pre.m_s1 == (int) PreambleType::T2LiteMISO); |
|
m_frequencies.assign(pre.m_numRf, 0); |
|
|
|
for (int i = 0; i < pre.m_numRf; i++) |
|
{ |
|
int index = L1Pre::getBits(bits, o, 3); |
|
uint32_t frequency = L1Pre::getBits(bits, o, 32); |
|
|
|
if (index < pre.m_numRf) { |
|
m_frequencies[index] = frequency; |
|
} |
|
} |
|
|
|
if (pre.m_s2 & 1) |
|
{ |
|
m_fefType = L1Pre::getBits(bits, o, 4); |
|
m_fefLength = L1Pre::getBits(bits, o, 22); |
|
m_fefInterval = L1Pre::getBits(bits, o, 8); |
|
} |
|
|
|
m_plps.resize(numPlp); |
|
|
|
for (PLP& plp : m_plps) |
|
{ |
|
plp.m_id = L1Pre::getBits(bits, o, 8); |
|
plp.m_type = L1Pre::getBits(bits, o, 3); |
|
plp.m_payloadType = L1Pre::getBits(bits, o, 5); |
|
plp.m_ffFlag = L1Pre::getBits(bits, o, 1); |
|
plp.m_firstRfIdx = L1Pre::getBits(bits, o, 3); |
|
plp.m_firstFrameIdx = L1Pre::getBits(bits, o, 8); |
|
plp.m_groupId = L1Pre::getBits(bits, o, 8); |
|
int cod = L1Pre::getBits(bits, o, 3); |
|
int mod = L1Pre::getBits(bits, o, 3); |
|
plp.m_rotation = L1Pre::getBits(bits, o, 1); |
|
int fec = L1Pre::getBits(bits, o, 2); |
|
plp.m_codeRate = (CodeRate) cod; |
|
plp.m_constellation = (Constellation) std::min(3, mod); |
|
plp.m_fecType = (FECType) std::min(1, fec); |
|
plp.m_valid = (mod <= 3) && (lite ? (fec == 0) && (cod != 4) && (cod != 5) : (fec <= 1) && (cod <= 5)); |
|
plp.m_numBlocksMax = L1Pre::getBits(bits, o, 10); |
|
plp.m_frameInterval = L1Pre::getBits(bits, o, 8); |
|
plp.m_timeIlLength = L1Pre::getBits(bits, o, 8); |
|
plp.m_timeIlType = L1Pre::getBits(bits, o, 1); |
|
plp.m_inBandA = L1Pre::getBits(bits, o, 1); |
|
plp.m_inBandB = L1Pre::getBits(bits, o, 1); |
|
plp.m_reserved1 = L1Pre::getBits(bits, o, 11); |
|
plp.m_plpMode = L1Pre::getBits(bits, o, 2); |
|
plp.m_staticFlag = L1Pre::getBits(bits, o, 1); |
|
plp.m_staticPaddingFlag = L1Pre::getBits(bits, o, 1); |
|
} |
|
|
|
m_fefLengthMsb = L1Pre::getBits(bits, o, 2); |
|
o += 30; // RESERVED_2 |
|
o += 32 * m_numAux; // AUX_STREAM_TYPE, AUX_PRIVATE_CONF |
|
|
|
// Dynamic, for the current frame |
|
m_frameIdx = L1Pre::getBits(bits, o, 8); |
|
m_subSliceInterval = L1Pre::getBits(bits, o, 22); |
|
m_type2Start = L1Pre::getBits(bits, o, 22); |
|
m_l1ChangeCounter = L1Pre::getBits(bits, o, 8); |
|
m_startRfIdx = L1Pre::getBits(bits, o, 3); |
|
o += 8; // RESERVED_1 |
|
|
|
for (PLP& plp : m_plps) |
|
{ |
|
int id = L1Pre::getBits(bits, o, 8); |
|
int start = L1Pre::getBits(bits, o, 22); |
|
int numBlocks = L1Pre::getBits(bits, o, 10); |
|
o += 8; // RESERVED_2 |
|
|
|
// The loop is in the same order as the configurable one |
|
if (id == plp.m_id) |
|
{ |
|
plp.m_start = start; |
|
plp.m_numBlocks = numBlocks; |
|
} |
|
} |
|
|
|
return o <= size; |
|
} |
|
|
|
void L1Post::encode(std::vector<uint8_t>& bits, L1Pre& pre) const |
|
{ |
|
bits.clear(); |
|
L1Pre::putBits(bits, m_subSlicesPerFrame, 15); |
|
L1Pre::putBits(bits, (uint32_t) m_plps.size(), 8); |
|
L1Pre::putBits(bits, m_numAux, 4); |
|
L1Pre::putBits(bits, m_auxConfigRfu, 8); |
|
|
|
for (int i = 0; i < pre.m_numRf; i++) |
|
{ |
|
L1Pre::putBits(bits, i, 3); |
|
L1Pre::putBits(bits, i < (int) m_frequencies.size() ? m_frequencies[i] : 0, 32); |
|
} |
|
|
|
if (pre.m_s2 & 1) |
|
{ |
|
L1Pre::putBits(bits, m_fefType, 4); |
|
L1Pre::putBits(bits, m_fefLength, 22); |
|
L1Pre::putBits(bits, m_fefInterval, 8); |
|
} |
|
|
|
for (const PLP& plp : m_plps) |
|
{ |
|
L1Pre::putBits(bits, plp.m_id, 8); |
|
L1Pre::putBits(bits, plp.m_type, 3); |
|
L1Pre::putBits(bits, plp.m_payloadType, 5); |
|
L1Pre::putBits(bits, plp.m_ffFlag, 1); |
|
L1Pre::putBits(bits, plp.m_firstRfIdx, 3); |
|
L1Pre::putBits(bits, plp.m_firstFrameIdx, 8); |
|
L1Pre::putBits(bits, plp.m_groupId, 8); |
|
L1Pre::putBits(bits, (int) plp.m_codeRate, 3); |
|
L1Pre::putBits(bits, (int) plp.m_constellation, 3); |
|
L1Pre::putBits(bits, plp.m_rotation, 1); |
|
L1Pre::putBits(bits, (int) plp.m_fecType, 2); |
|
L1Pre::putBits(bits, plp.m_numBlocksMax, 10); |
|
L1Pre::putBits(bits, plp.m_frameInterval, 8); |
|
L1Pre::putBits(bits, plp.m_timeIlLength, 8); |
|
L1Pre::putBits(bits, plp.m_timeIlType, 1); |
|
L1Pre::putBits(bits, plp.m_inBandA, 1); |
|
L1Pre::putBits(bits, plp.m_inBandB, 1); |
|
L1Pre::putBits(bits, plp.m_reserved1, 11); |
|
L1Pre::putBits(bits, plp.m_plpMode, 2); |
|
L1Pre::putBits(bits, plp.m_staticFlag, 1); |
|
L1Pre::putBits(bits, plp.m_staticPaddingFlag, 1); |
|
} |
|
|
|
L1Pre::putBits(bits, m_fefLengthMsb, 2); |
|
L1Pre::putBits(bits, 0, 30); |
|
|
|
for (int i = 0; i < m_numAux; i++) { |
|
L1Pre::putBits(bits, 0, 32); |
|
} |
|
|
|
L1Pre::putBits(bits, m_frameIdx, 8); |
|
L1Pre::putBits(bits, m_subSliceInterval, 22); |
|
L1Pre::putBits(bits, m_type2Start, 22); |
|
L1Pre::putBits(bits, m_l1ChangeCounter, 8); |
|
L1Pre::putBits(bits, m_startRfIdx, 3); |
|
L1Pre::putBits(bits, 0, 8); |
|
|
|
for (const PLP& plp : m_plps) |
|
{ |
|
L1Pre::putBits(bits, plp.m_id, 8); |
|
L1Pre::putBits(bits, plp.m_start, 22); |
|
L1Pre::putBits(bits, plp.m_numBlocks, 10); |
|
L1Pre::putBits(bits, 0, 8); |
|
} |
|
|
|
L1Pre::putBits(bits, 0, 8); // RESERVED_3 |
|
|
|
for (int i = 0; i < m_numAux; i++) { |
|
L1Pre::putBits(bits, 0, 48); |
|
} |
|
|
|
pre.m_l1PostInfoSize = (int) bits.size(); |
|
uint32_t crc = crc32(bits.data(), (int) bits.size()); |
|
L1Pre::putBits(bits, crc, 32); |
|
} |
|
|
|
int framePN(int l) |
|
{ |
|
if ((l < 0) || (l >= framePNLength)) { |
|
return 0; |
|
} |
|
|
|
int digit = l / 4; |
|
char c = tables::frameLevelPN[digit]; |
|
int value = c <= '9' ? c - '0' : c - 'A' + 10; |
|
return (value >> (3 - (l % 4))) & 1; |
|
} |
|
|
|
int Tables::fftIndex(int fftSize) |
|
{ |
|
switch (fftSize) |
|
{ |
|
case 1024: return 0; |
|
case 2048: return 1; |
|
case 4096: return 2; |
|
case 8192: return 3; |
|
case 16384: return 4; |
|
default: return 5; |
|
} |
|
} |
|
|
|
// Table 50: active cells in the frame closing symbol, without tone reservation |
|
int Tables::frameClosingActiveCells(int fftSize, bool extended, PilotPattern pattern) |
|
{ |
|
static const int normal[6][8] = { |
|
{402, 654, 490, 707, 544, 0, 0, 0}, |
|
{804, 1309, 980, 1415, 1088, 0, 1396, 0}, |
|
{1609, 2619, 1961, 2831, 2177, 0, 2792, 0}, |
|
{3218, 5238, 3922, 5662, 4354, 0, 5585, 0}, |
|
{6437, 10476, 7845, 11324, 8709, 11801, 11170, 0}, |
|
{0, 20952, 0, 22649, 0, 23603, 0, 0}, |
|
}; |
|
static const int ext[6][8] = { |
|
{0, 0, 0, 0, 0, 0, 0, 0}, |
|
{0, 0, 0, 0, 0, 0, 0, 0}, |
|
{0, 0, 0, 0, 0, 0, 0, 0}, |
|
{3264, 5312, 3978, 5742, 4416, 0, 5664, 0}, |
|
{6573, 10697, 8011, 11563, 8893, 12051, 11406, 0}, |
|
{0, 21395, 0, 23127, 0, 24102, 0, 0}, |
|
}; |
|
return (extended ? ext : normal)[fftIndex(fftSize)][(int) pattern]; |
|
} |
|
|
|
const Tables& Tables::get(int fftSize, bool extended, PilotPattern pattern, bool toneReservation, bool miso) |
|
{ |
|
static std::mutex mutex; |
|
static std::map<std::tuple<int, bool, int, bool, bool>, Tables*> cache; |
|
std::lock_guard<std::mutex> lock(mutex); |
|
auto key = std::make_tuple(fftSize, extended, (int) pattern, toneReservation, miso); |
|
auto it = cache.find(key); |
|
|
|
if (it != cache.end()) { |
|
return *it->second; |
|
} |
|
|
|
Tables *tables = new Tables(fftSize, extended, pattern, toneReservation, miso); |
|
cache[key] = tables; |
|
return *tables; |
|
} |
|
|
|
Tables::Tables(int fftSize, bool extended, PilotPattern pattern, bool toneReservation, bool miso) : |
|
m_fftSize(fftSize), |
|
m_extended(extended && (kExt(fftSize) > 0)), |
|
m_pattern(pattern), |
|
m_toneReservation(toneReservation), |
|
m_miso(miso), |
|
m_kExt(m_extended ? kExt(fftSize) : 0), |
|
m_dx(dx(pattern)), |
|
m_dy(dy(pattern)) |
|
{ |
|
m_kMax = kMaxNormal(fftSize) + 2 * m_kExt; |
|
const int nbCarriers = m_kMax + 1; |
|
const int fi = fftIndex(fftSize); |
|
|
|
// Symbol level PRBS x^11 + x^2 + 1, from all ones. Its first bit is on the first carrier of extended mode |
|
const int offset = kExt(fftSize) - m_kExt; |
|
std::vector<uint8_t> prbs(nbCarriers + offset); |
|
unsigned int reg = 0x7ff; |
|
|
|
for (size_t k = 0; k < prbs.size(); k++) |
|
{ |
|
prbs[k] = reg & 1; |
|
unsigned int bit = (reg ^ (reg >> 2)) & 1; |
|
reg = (reg >> 1) | (bit << 10); |
|
} |
|
|
|
m_w.assign(prbs.begin() + offset, prbs.end()); |
|
|
|
// P2 symbols (9.2.6): pilots every 6 carriers in 32K SISO, else every 3, plus the extended carriers, and in MISO |
|
// the two carriers next to each edge of the normal carriers (9.2.8) |
|
const bool siso32K = (fftSize == 32768) && !miso; |
|
const int p2Spacing = siso32K ? 6 : 3; |
|
const float p2Amplitude = std::sqrt(siso32K ? 37.0f : 31.0f) / 5.0f; |
|
std::vector<uint8_t> p2Reserved(nbCarriers, 0); |
|
|
|
for (int i = 0; i < tables::p2ReservedCarriersIndex[fi][1]; i++) { |
|
p2Reserved[tables::p2ReservedCarriers[tables::p2ReservedCarriersIndex[fi][0] + i] + m_kExt] = 1; |
|
} |
|
|
|
for (int k = 0; k < nbCarriers; k++) |
|
{ |
|
bool pilot = (k % p2Spacing == 0) || (k < m_kExt) || (k > m_kMax - m_kExt); |
|
|
|
// And next to the reserved carriers, unless reserved too |
|
if (miso && ((k == m_kExt + 1) || (k == m_kExt + 2) || (k == m_kMax - m_kExt - 2) || (k == m_kMax - m_kExt - 1) |
|
|| (!p2Reserved[k] && (((k > 0) && p2Reserved[k - 1]) || ((k < m_kMax) && p2Reserved[k + 1]))))) |
|
{ |
|
pilot = true; |
|
} |
|
|
|
if (pilot) { |
|
m_p2Pilots.push_back({k, p2Amplitude}); |
|
} else if (!p2Reserved[k]) { |
|
m_p2Data.push_back(k); |
|
} |
|
} |
|
|
|
// Continual pilots (9.2.4): from the 32K indices, modulo Kmod in the smaller modes, plus extended carrier mode's |
|
// 1K has group 1 (CP1), 2K groups 1 and 2, and so on, up to 32K's six |
|
static const int kMod[] = {1632, 1632, 3264, 6528, 13056, 0}; |
|
const int nbGroups = fi + 1; |
|
std::vector<uint8_t> continual(nbCarriers, 0); |
|
|
|
for (int g = 0; g < nbGroups; g++) |
|
{ |
|
const int *index = tables::continualPilotIndex[g][(int) pattern]; |
|
|
|
for (int i = 0; i < index[1]; i++) |
|
{ |
|
int k = tables::continualPilots[index[0] + i]; |
|
k = kMod[fi] ? k % kMod[fi] : k; |
|
|
|
if (k <= m_kMax) { |
|
continual[k] = 1; |
|
} |
|
} |
|
} |
|
|
|
if (m_extended) |
|
{ |
|
const int *index = tables::extendedContinualPilotIndex[fi - 3][(int) pattern]; |
|
|
|
for (int i = 0; i < index[1]; i++) { |
|
continual[tables::extendedContinualPilots[index[0] + i]] = 1; |
|
} |
|
} |
|
|
|
for (int k = 0; k < nbCarriers; k++) |
|
{ |
|
if (continual[k]) { |
|
m_continual.push_back(k); |
|
} |
|
} |
|
|
|
// Normal symbols (9.2.3 to 9.2.5, 9.3) |
|
static const float spAmplitudes[] = {4.0f / 3.0f, 4.0f / 3.0f, 7.0f / 4.0f, 7.0f / 4.0f, 7.0f / 3.0f, 7.0f / 3.0f, 7.0f / 3.0f, 7.0f / 3.0f}; |
|
static const float cpAmplitudes[] = {4.0f / 3.0f, 4.0f / 3.0f, 4.0f * std::sqrt(2.0f) / 3.0f, 8.0f / 3.0f, 8.0f / 3.0f, 8.0f / 3.0f}; |
|
const float spAmplitude = spAmplitudes[(int) pattern]; |
|
const float cpAmplitude = cpAmplitudes[fi]; |
|
const int period = m_dx * m_dy; |
|
|
|
for (int phase = 0; phase < m_dy; phase++) |
|
{ |
|
std::vector<uint8_t> reserved(nbCarriers, 0); |
|
|
|
// Reserved carriers move with the scattered pilots, which in extended mode are offset by Kext |
|
if (toneReservation) |
|
{ |
|
for (int i = 0; i < tables::reservedCarriersIndex[fi][1]; i++) |
|
{ |
|
int k = tables::reservedCarriers[tables::reservedCarriersIndex[fi][0] + i] + m_dx * ((phase + m_kExt / m_dx) % m_dy); |
|
|
|
if (k <= m_kMax) { |
|
reserved[k] = 1; |
|
} |
|
} |
|
} |
|
|
|
for (int k = 0; k < nbCarriers; k++) |
|
{ |
|
bool scattered = (((k - m_kExt) % period + period) % period) == m_dx * phase; |
|
|
|
if (scattered || (k == 0) || (k == m_kMax)) { |
|
m_pilots[phase].push_back({k, spAmplitude}); |
|
} else if (continual[k]) { |
|
m_pilots[phase].push_back({k, cpAmplitude}); |
|
} else if (!reserved[k]) { |
|
m_data[phase].push_back(k); |
|
} |
|
} |
|
|
|
// For frequency interpolation from this symbol's pilots alone |
|
const int spOffset = (m_kExt + m_dx * phase) % period; |
|
|
|
for (const Pilot& pilot : m_pilots[phase]) |
|
{ |
|
if ((pilot.m_k - spOffset) % period == 0) { |
|
m_scattered[phase].push_back(pilot); |
|
} |
|
} |
|
} |
|
|
|
// Frame closing symbol (9.2.7): pilots every Dx carriers, and the edges. Tone reservation as for P2 |
|
for (int k = 0; k < nbCarriers; k++) |
|
{ |
|
bool extra = (k == m_kMax - 1) && (((fftSize == 1024) && ((pattern == PilotPattern::PP4) || (pattern == PilotPattern::PP5))) |
|
|| ((fftSize == 2048) && (pattern == PilotPattern::PP7))); |
|
|
|
if ((k % m_dx == 0) || (k == m_kMax) || extra) { |
|
m_fcPilots.push_back({k, spAmplitude}); |
|
} else if (!(toneReservation && p2Reserved[k])) { |
|
m_fcData.push_back(k); |
|
} |
|
} |
|
|
|
m_cfc = frameClosingActiveCells(fftSize, m_extended, pattern); |
|
|
|
if (toneReservation) { |
|
m_cfc -= tables::reservedCarriersIndex[fi][1]; |
|
} |
|
|
|
interleaver((int) m_p2Data.size(), m_p2Read); |
|
interleaver((int) m_data[0].size(), m_dataRead); |
|
interleaver((int) m_fcData.size(), m_fcRead); |
|
} |
|
|
|
// Frequency interleaver (8.5). read[parity][p] is the index of the data carrier holding cell p |
|
void Tables::interleaver(int ndata, std::vector<int> read[2]) const |
|
{ |
|
// Bit permutations of tables 53, R' bit j to R bit perm[j] |
|
static const int perm1K[2][9] = {{8, 7, 6, 5, 0, 1, 2, 3, 4}, {6, 8, 7, 4, 1, 0, 5, 2, 3}}; |
|
static const int perm2K[2][10] = {{4, 3, 9, 6, 2, 8, 1, 5, 7, 0}, {6, 9, 4, 8, 5, 1, 0, 7, 2, 3}}; |
|
static const int perm4K[2][11] = {{6, 3, 0, 9, 4, 2, 1, 8, 5, 10, 7}, {5, 9, 1, 4, 3, 0, 8, 10, 7, 2, 6}}; |
|
static const int perm8K[2][12] = {{7, 1, 4, 2, 9, 6, 8, 10, 0, 3, 11, 5}, {11, 4, 9, 3, 1, 2, 5, 0, 6, 7, 10, 8}}; |
|
static const int perm16K[2][13] = {{9, 7, 6, 10, 12, 5, 1, 11, 0, 2, 3, 4, 8}, {6, 8, 10, 12, 2, 0, 4, 1, 11, 3, 5, 9, 7}}; |
|
static const int perm32K[14] = {7, 13, 3, 4, 9, 2, 12, 11, 1, 8, 10, 0, 5, 6}; |
|
|
|
const int nr = (int) std::lround(std::log2((double) m_fftSize)); |
|
const int mMax = m_fftSize; |
|
const int fi = fftIndex(m_fftSize); |
|
|
|
for (int parity = 0; parity < 2; parity++) |
|
{ |
|
const int *perm; |
|
|
|
switch (fi) |
|
{ |
|
case 0: perm = perm1K[parity]; break; |
|
case 1: perm = perm2K[parity]; break; |
|
case 2: perm = perm4K[parity]; break; |
|
case 3: perm = perm8K[parity]; break; |
|
case 4: perm = perm16K[parity]; break; |
|
default: perm = perm32K; break; |
|
} |
|
|
|
std::vector<int> h(ndata); |
|
unsigned int rp = 0; |
|
|
|
for (int i = 0, p = 0; (i < mMax) && (p < ndata); i++) |
|
{ |
|
if (i < 2) { |
|
rp = 0; |
|
} else if (i == 2) { |
|
rp = 1; |
|
} |
|
else |
|
{ |
|
unsigned int bit; |
|
|
|
switch (fi) |
|
{ |
|
case 0: bit = (rp ^ (rp >> 4)) & 1; break; |
|
case 1: bit = (rp ^ (rp >> 3)) & 1; break; |
|
case 2: bit = (rp ^ (rp >> 2)) & 1; break; |
|
case 3: bit = (rp ^ (rp >> 1) ^ (rp >> 4) ^ (rp >> 6)) & 1; break; |
|
case 4: bit = (rp ^ (rp >> 1) ^ (rp >> 4) ^ (rp >> 5) ^ (rp >> 9) ^ (rp >> 11)) & 1; break; |
|
default: bit = (rp ^ (rp >> 1) ^ (rp >> 2) ^ (rp >> 12)) & 1; break; |
|
} |
|
|
|
rp = (rp >> 1) | (bit << (nr - 2)); |
|
} |
|
|
|
unsigned int r = 0; |
|
|
|
for (int j = 0; j < nr - 1; j++) { |
|
r |= ((rp >> j) & 1) << perm[j]; |
|
} |
|
|
|
int value = (i % 2) * (1 << (nr - 1)) + (int) r; |
|
|
|
if (value < ndata) { |
|
h[p++] = value; |
|
} |
|
} |
|
|
|
// 1K-16K: a[p] = x[H(p)], with H0 on even and H1 on odd symbols. |
|
// 32K: a[H(p)] = x[p] on even symbols and a[p] = x[H(p)] on odd |
|
read[parity].resize(ndata); |
|
|
|
for (int p = 0; p < ndata; p++) |
|
{ |
|
if ((fi == 5) && (parity == 0)) { |
|
read[parity][p] = h[p]; |
|
} else { |
|
read[parity][h[p]] = p; |
|
} |
|
} |
|
} |
|
} |
|
|
|
const P1Tables& P1Tables::get() |
|
{ |
|
static P1Tables tables; |
|
return tables; |
|
} |
|
|
|
P1Tables::P1Tables() |
|
{ |
|
std::copy(tables::p1Carriers, tables::p1Carriers + 384, m_carriers); |
|
|
|
auto hexBits = [](const char *hex, uint8_t *bits) { |
|
for (int i = 0; hex[i]; i++) |
|
{ |
|
int value = hex[i] <= '9' ? hex[i] - '0' : hex[i] - 'A' + 10; |
|
|
|
for (int b = 0; b < 4; b++) { |
|
bits[4 * i + b] = (value >> (3 - b)) & 1; |
|
} |
|
} |
|
}; |
|
|
|
for (int i = 0; i < 8; i++) { |
|
hexBits(tables::p1S1[i], m_s1[i]); |
|
} |
|
|
|
for (int i = 0; i < 16; i++) { |
|
hexBits(tables::p1S2[i], m_s2[i]); |
|
} |
|
|
|
// PRBS of 5.2.4 from 100111001000110 |
|
unsigned int st = 0x3139; |
|
|
|
for (int i = 0; i < 384; i++) |
|
{ |
|
unsigned int bit = ((st >> 13) ^ (st >> 14)) & 1; |
|
st = (st << 1) | bit; |
|
m_scrambling[i] = bit; |
|
} |
|
} |
|
|
|
// 9.8.2.2: CSS_S1, CSS_S2, CSS_S1, DBPSK from +1, then scrambled |
|
void P1Tables::modulation(int s1, int s2, float *values) const |
|
{ |
|
uint8_t sequence[384]; |
|
std::copy(m_s1[s1], m_s1[s1] + 64, sequence); |
|
std::copy(m_s2[s2], m_s2[s2] + 256, sequence + 64); |
|
std::copy(m_s1[s1], m_s1[s1] + 64, sequence + 320); |
|
float diff = 1.0f; |
|
|
|
for (int i = 0; i < 384; i++) |
|
{ |
|
diff = sequence[i] ? -diff : diff; |
|
values[i] = m_scrambling[i] ? -diff : diff; |
|
} |
|
} |
|
|
|
} // namespace dvbt2
|
|
|