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.
554 lines
18 KiB
554 lines
18 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 <cmath> |
|
|
|
#include <QString> |
|
|
|
#include "dsp/fftengine.h" |
|
|
|
#include "dvbt2modulator.h" |
|
|
|
namespace dvbt2 { |
|
|
|
Modulator::Modulator(const Config& config) : |
|
m_config(config), |
|
m_frameIdx(0) |
|
{ |
|
m_fft = FFTEngine::create(QString()); |
|
setup(); |
|
} |
|
|
|
Modulator::~Modulator() |
|
{ |
|
delete m_fft; |
|
} |
|
|
|
// S2 field 1 (table 19(a)) |
|
int Modulator::s2Field1(int fftSize, GuardInterval guard, bool lite) |
|
{ |
|
bool newGuard = (guard == GuardInterval::G1_128) || (guard == GuardInterval::G19_128) || (guard == GuardInterval::G19_256); |
|
|
|
switch (fftSize) |
|
{ |
|
case 1024: return 3; |
|
case 2048: return 0; |
|
case 4096: return 2; |
|
case 8192: return newGuard ? 6 : 1; |
|
case 16384: return lite && newGuard ? 3 : 4; |
|
default: return newGuard ? 7 : 5; |
|
} |
|
} |
|
|
|
void Modulator::setup() |
|
{ |
|
const Config& c = m_config; |
|
const int n = c.m_fftSize; |
|
const int ng = guardSamples(n, c.m_guard); |
|
const int np2 = numP2(n); |
|
m_tables = &Tables::get(n, c.m_extended, c.m_pattern, c.m_toneReservation, c.m_miso); |
|
m_frameClosing = frameClosingSymbol(n, c.m_guard, c.m_pattern, c.m_miso); |
|
|
|
// Frame length: at most 250 ms. 32K frames have an even number of symbols |
|
int lf = c.m_dataSymbols > 0 ? c.m_dataSymbols + np2 : (int) ((0.25 * sampleRate(c.m_bandwidth) - 2048) / (n + ng)); |
|
|
|
if ((n == 32768) && (lf % 2)) { |
|
lf--; |
|
} |
|
|
|
m_lf = lf; |
|
const int ldata = lf - np2; |
|
|
|
m_pre = L1Pre(); |
|
m_pre.m_type = 0; |
|
m_pre.m_bwtExt = m_tables->m_extended; |
|
m_pre.m_s1 = c.m_lite ? (int) (c.m_miso ? PreambleType::T2LiteMISO : PreambleType::T2LiteSISO) |
|
: (int) (c.m_miso ? PreambleType::T2MISO : PreambleType::T2SISO); |
|
m_pre.m_s2 = (s2Field1(n, c.m_guard, c.m_lite) << 1) | (c.m_fefLength > 0 ? 1 : 0); |
|
m_pre.m_guard = c.m_guard; |
|
m_pre.m_papr = c.m_toneReservation ? 2 : 0; |
|
m_pre.m_l1Mod = c.m_l1Mod; |
|
m_pre.m_pilotPattern = c.m_pattern; |
|
m_pre.m_cellId = c.m_cellId; |
|
m_pre.m_networkId = 0x3001; |
|
m_pre.m_t2SystemId = 0x8001; |
|
m_pre.m_numT2Frames = c.m_frames; |
|
m_pre.m_numDataSymbols = ldata; |
|
m_pre.m_numRf = 1; |
|
m_pre.m_t2Version = 2; |
|
|
|
m_ncells = cellsPerFECBlock(c.m_fecType, c.m_constellation); |
|
PLP plp; |
|
plp.m_id = 0; |
|
plp.m_type = 1; |
|
plp.m_payloadType = 3; |
|
plp.m_codeRate = c.m_codeRate; |
|
plp.m_constellation = c.m_constellation; |
|
plp.m_rotation = c.m_rotation; |
|
plp.m_fecType = c.m_fecType; |
|
plp.m_frameInterval = 1; |
|
plp.m_plpMode = c.m_highEfficiency ? 2 : 1; |
|
m_post = L1Post(); |
|
m_post.m_frequencies.push_back(0); |
|
m_post.m_plps.push_back(plp); |
|
|
|
if (c.m_fefLength > 0) |
|
{ |
|
m_post.m_fefType = 0; |
|
m_post.m_fefLength = c.m_fefLength & 0x3fffff; |
|
m_post.m_fefLengthMsb = c.m_fefLength >> 22; |
|
m_post.m_fefInterval = std::max(1, c.m_fefInterval); |
|
} |
|
|
|
// Capacity: L1 signalling first, then the PLP, then dummy cells |
|
std::vector<uint8_t> postBits; |
|
m_post.encode(postBits, m_pre); |
|
m_pre.m_l1PostSize = L1Codec::postCells(m_pre.m_l1PostInfoSize, c.m_l1Mod, n); |
|
const int dl1 = l1PreCells + m_pre.m_l1PostSize; |
|
const int cdata = (int) m_tables->m_data[0].size(); |
|
const int ctot = np2 * (int) m_tables->m_p2Data.size() + (ldata - 1) * cdata + (m_frameClosing ? m_tables->m_cfc : cdata); |
|
m_blocksPerFrame = (ctot - dl1) / m_ncells; |
|
const int pi = std::max(1, c.m_interleavingFrames); |
|
int nti = c.m_tiBlocks; |
|
|
|
if (pi > 1) |
|
{ |
|
// PI of an Interleaving Frame's cells must be an integer (8.3.6.3.1) |
|
m_blocksPerFrame = std::min(pi * m_blocksPerFrame, m_maxTICells / m_ncells); |
|
m_post.m_plps[0].m_timeIlType = true; |
|
m_post.m_plps[0].m_timeIlLength = pi; |
|
} |
|
else |
|
{ |
|
if (nti > 0) |
|
{ |
|
while (((m_blocksPerFrame + nti - 1) / nti) * m_ncells > m_maxTICells) { |
|
nti++; |
|
} |
|
} |
|
|
|
m_post.m_plps[0].m_timeIlLength = nti; |
|
} |
|
|
|
m_post.m_plps[0].m_frameInterval = std::max(1, c.m_frameInterval); |
|
m_post.m_plps[0].m_numBlocksMax = m_blocksPerFrame; |
|
m_post.m_plps[0].m_numBlocks = m_blocksPerFrame; |
|
m_post.m_plps[0].m_start = 0; |
|
m_post.m_type2Start = m_blocksPerFrame * m_ncells / pi; |
|
|
|
m_ldpc.reset(new LDPC(c.m_fecType, c.m_codeRate)); |
|
m_bch.reset(new BCH(c.m_fecType, bchT(c.m_fecType, c.m_codeRate))); |
|
m_bbEncoder.reset(new BBFrameEncoder(c.m_fecType, c.m_codeRate, c.m_highEfficiency)); |
|
m_cellInterleaver.reset(new CellInterleaver(m_ncells)); |
|
cellBitMap(c.m_fecType, c.m_codeRate, c.m_constellation, m_bitMap); |
|
m_packetsPerFrame = (int) std::ceil(m_blocksPerFrame * (double) (kbch(c.m_fecType, c.m_codeRate) - 80) / (188 * 8) |
|
/ (pi * std::max(1, c.m_frameInterval))); |
|
|
|
makeP1(m_pre.m_s1, m_pre.m_s2, m_p1); |
|
|
|
if (c.m_fefLength > 0) { |
|
makeP1(c.m_fefS1, 0, m_fefP1); |
|
} |
|
|
|
m_fft->configure(n, true); |
|
} |
|
|
|
// P1 (9.8): the A part from the active carriers, then C and B, frequency shifted copies of its start and end |
|
void Modulator::makeP1(int s1, int s2, std::vector<Cf>& p1Samples) |
|
{ |
|
float values[384]; |
|
const P1Tables& p1 = P1Tables::get(); |
|
p1.modulation(s1, s2, values); |
|
m_fft->configure(1024, true); |
|
Cf *in = m_fft->in(); |
|
std::fill(in, in + 1024, Cf(0.0f, 0.0f)); |
|
|
|
for (int i = 0; i < 384; i++) { |
|
in[(p1.m_carriers[i] - 426 + 1024) % 1024] = Cf(values[i] / std::sqrt(384.0f), 0.0f); |
|
} |
|
|
|
m_fft->transform(); |
|
const Cf *a = m_fft->out(); |
|
p1Samples.resize(2048); |
|
|
|
for (int i = 0; i < 2048; i++) |
|
{ |
|
Cf shift = std::polar(1.0f, (float) (2.0 * M_PI * i / 1024.0)); |
|
|
|
if (i < 542) { |
|
p1Samples[i] = a[i] * shift; |
|
} else if (i < 1566) { |
|
p1Samples[i] = a[i - 542]; |
|
} else { |
|
p1Samples[i] = a[i - 1024] * shift; |
|
} |
|
} |
|
} |
|
|
|
// A FEF part (8.4): a P1, then anything, here noise at the T2 signal's power |
|
void Modulator::addFEF(std::vector<Cf>& samples) |
|
{ |
|
const size_t start = samples.size(); |
|
samples.insert(samples.end(), m_fefP1.begin(), m_fefP1.end()); |
|
std::normal_distribution<float> noise(0.0f, (float) std::sqrt(0.5)); |
|
|
|
for (int i = (int) m_fefP1.size(); i < m_config.m_fefLength; i++) { |
|
samples.push_back(Cf(noise(m_fefRng), noise(m_fefRng))); |
|
} |
|
|
|
if (m_tx2) { |
|
m_tx2->insert(m_tx2->end(), samples.begin() + start, samples.end()); |
|
} |
|
} |
|
|
|
int Modulator::samplesPerFrame() const |
|
{ |
|
return 2048 + m_lf * (m_config.m_fftSize + guardSamples(m_config.m_fftSize, m_config.m_guard)); |
|
} |
|
|
|
// BCH, LDPC, bit interleaving and mapping (6.1, 6.2), then rotation (6.3) |
|
void Modulator::encodeFECBlock(const std::vector<uint8_t>& bbframe, std::vector<Cf>& cells) |
|
{ |
|
const int kbchBytes = (int) bbframe.size(); |
|
const int k = m_ldpc->k(); |
|
const int n = m_ldpc->n(); |
|
std::vector<uint8_t> packed(k / 8); |
|
std::copy(bbframe.begin(), bbframe.end(), packed.begin()); |
|
m_bch->encode(packed.data(), kbchBytes, packed.data() + kbchBytes); |
|
std::vector<uint8_t> codeword(n); |
|
|
|
for (int i = 0; i < k; i++) { |
|
codeword[i] = (packed[i / 8] >> (7 - (i % 8))) & 1; |
|
} |
|
|
|
m_ldpc->encode(codeword.data(), codeword.data() + k); |
|
|
|
const int eta = bitsPerCell(m_config.m_constellation); |
|
std::vector<Cf> f(m_ncells); |
|
uint8_t bits[8]; |
|
|
|
for (int q = 0; q < m_ncells; q++) |
|
{ |
|
for (int e = 0; e < eta; e++) { |
|
bits[e] = codeword[m_bitMap[q * eta + e]]; |
|
} |
|
|
|
f[q] = mapCell(bits, eta); |
|
} |
|
|
|
cells.resize(m_ncells); |
|
|
|
if (m_config.m_rotation) |
|
{ |
|
Cf r = std::polar(1.0f, rotationAngle(m_config.m_constellation)); |
|
|
|
for (int q = 0; q < m_ncells; q++) |
|
{ |
|
Cf a = r * f[q]; |
|
Cf b = r * f[(q + m_ncells - 1) % m_ncells]; |
|
cells[q] = Cf(a.real(), b.imag()); |
|
} |
|
} |
|
else |
|
{ |
|
cells = f; |
|
} |
|
} |
|
|
|
void Modulator::modulate(const uint8_t *packets, int nbPackets, std::vector<Cf>& samples, std::vector<Cf> *samples2) |
|
{ |
|
m_tx2 = m_config.m_miso ? samples2 : nullptr; |
|
|
|
std::vector<uint8_t> bbframe; |
|
|
|
for (int p = 0; p < nbPackets; p++) |
|
{ |
|
if (m_bbEncoder->addPacket(packets + 188 * p, bbframe)) { |
|
m_bbframes.push_back(bbframe); |
|
} |
|
|
|
while ((int) m_bbframes.size() >= blocksNeeded()) { |
|
buildFrame(samples); |
|
} |
|
} |
|
} |
|
|
|
// Blocks the next frame takes: an Interleaving Frame's, if it's the first it's in |
|
int Modulator::blocksNeeded() const |
|
{ |
|
const int ijump = std::max(1, m_config.m_frameInterval); |
|
const int pi = std::max(1, m_config.m_interleavingFrames); |
|
return ((m_frameIdx % ijump) == 0) && (((m_frameIdx / ijump) % pi) == 0) ? m_blocksPerFrame : 0; |
|
} |
|
|
|
void Modulator::buildFrame(std::vector<Cf>& samples) |
|
{ |
|
const Config& c = m_config; |
|
const int ijump = std::max(1, c.m_frameInterval); |
|
const int pi = std::max(1, c.m_interleavingFrames); |
|
const bool present = (m_frameIdx % ijump) == 0; |
|
const int part = (m_frameIdx / ijump) % pi; |
|
|
|
// The PLP's cells in this frame: part of the Interleaving Frame (8.3.6.3.1) |
|
std::vector<Cf> plpCells; |
|
|
|
if (present) |
|
{ |
|
if (part == 0) { |
|
encodeInterleavingFrame(); |
|
} |
|
|
|
const size_t d = m_ifCells.size() / pi; |
|
plpCells.assign(m_ifCells.begin() + part * d, m_ifCells.begin() + (part + 1) * d); |
|
} |
|
|
|
m_post.m_plps[0].m_start = 0; |
|
m_post.m_type2Start = (int) plpCells.size(); |
|
buildFrameCells(plpCells, samples); |
|
} |
|
|
|
// The PLP's cells: cell and time interleaving of the FEC blocks (6.4, 6.5) |
|
void Modulator::encodeInterleavingFrame() |
|
{ |
|
const PLP& plp = m_post.m_plps[0]; |
|
std::vector<Cf>& plpCells = m_ifCells; |
|
plpCells.clear(); |
|
plpCells.reserve((size_t) m_blocksPerFrame * m_ncells); |
|
std::vector<std::vector<Cf>> blocks(m_blocksPerFrame); |
|
|
|
for (int b = 0; b < m_blocksPerFrame; b++) { |
|
encodeFECBlock(m_bbframes[b], blocks[b]); |
|
} |
|
|
|
m_bbframes.erase(m_bbframes.begin(), m_bbframes.begin() + m_blocksPerFrame); |
|
|
|
const int nti = plp.m_timeIlType ? 1 : plp.m_timeIlLength; |
|
|
|
if (nti == 0) |
|
{ |
|
for (int b = 0; b < m_blocksPerFrame; b++) |
|
{ |
|
std::vector<Cf> d(m_ncells); |
|
|
|
for (int q = 0; q < m_ncells; q++) { |
|
d[m_cellInterleaver->address(0, q)] = blocks[b][q]; |
|
} |
|
|
|
plpCells.insert(plpCells.end(), d.begin(), d.end()); |
|
} |
|
} |
|
else |
|
{ |
|
int b = 0; |
|
|
|
for (int s = 0; s < nti; s++) |
|
{ |
|
int nfec = m_blocksPerFrame / nti + (s >= nti - (m_blocksPerFrame % nti) ? 1 : 0); |
|
std::vector<Cf> d((size_t) nfec * m_ncells); |
|
|
|
for (int r = 0; r < nfec; r++, b++) |
|
{ |
|
for (int q = 0; q < m_ncells; q++) { |
|
d[(size_t) r * m_ncells + m_cellInterleaver->address(r, q)] = blocks[b][q]; |
|
} |
|
} |
|
|
|
std::vector<int> read; |
|
timeInterleaver(m_ncells, nfec, read); |
|
|
|
for (size_t i = 0; i < read.size(); i++) { |
|
plpCells.push_back(d[read[i]]); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// L1, the PLP's cells and dummy cells into the frame's symbols |
|
void Modulator::buildFrameCells(std::vector<Cf>& plpCells, std::vector<Cf>& samples) |
|
{ |
|
const Config& c = m_config; |
|
const int np2 = numP2(c.m_fftSize); |
|
|
|
// L1 signalling for this frame |
|
m_post.m_frameIdx = m_frameIdx; |
|
std::vector<uint8_t> postBits; |
|
m_post.encode(postBits, m_pre); |
|
std::vector<Cf> postCells, preCells; |
|
m_l1Codec.encodePost(postBits, m_pre, postCells); |
|
uint8_t preBits[L1Pre::size]; |
|
m_pre.encode(preBits); |
|
m_l1Codec.encodePre(preBits, preCells); |
|
|
|
// Dummy cells (8.3.8): the BB scrambling sequence, BPSK |
|
const int cp2 = (int) m_tables->m_p2Data.size(); |
|
const int cdata = (int) m_tables->m_data[0].size(); |
|
const int dl1 = (int) (preCells.size() + postCells.size()); |
|
const int ctot = np2 * cp2 + (m_lf - np2 - 1) * cdata + (m_frameClosing ? m_tables->m_cfc : cdata); |
|
const int ndummy = ctot - dl1 - (int) plpCells.size(); |
|
std::vector<uint8_t> dummyBits(ndummy, 0); |
|
scramble(dummyBits.data(), ndummy); |
|
|
|
for (int i = 0; i < ndummy; i++) { |
|
plpCells.push_back(Cf(dummyBits[i] ? -1.0f : 1.0f, 0.0f)); |
|
} |
|
|
|
// Map to the symbols (8.3.5, 8.3.6.2): L1 zig-zag across the P2 symbols, then the cells in address order |
|
addP1(samples); |
|
size_t address = 0; |
|
const int preRows = (int) preCells.size() / np2; |
|
const int postRows = (int) postCells.size() / np2; |
|
|
|
for (int l = 0; l < m_lf; l++) |
|
{ |
|
std::vector<Cf> cells; |
|
|
|
if (l < np2) |
|
{ |
|
cells.resize(cp2); |
|
|
|
for (int p = 0; p < preRows; p++) { |
|
cells[p] = preCells[np2 * p + l]; |
|
} |
|
|
|
for (int p = 0; p < postRows; p++) { |
|
cells[preRows + p] = postCells[np2 * p + l]; |
|
} |
|
|
|
for (int p = preRows + postRows; p < cp2; p++) { |
|
cells[p] = plpCells[address++]; |
|
} |
|
} |
|
else if (m_frameClosing && (l == m_lf - 1)) |
|
{ |
|
cells.assign(m_tables->m_fcData.size(), Cf(0.0f, 0.0f)); |
|
|
|
for (int p = 0; p < m_tables->m_cfc; p++) { |
|
cells[p] = plpCells[address++]; |
|
} |
|
} |
|
else |
|
{ |
|
cells.resize(cdata); |
|
|
|
for (int p = 0; p < cdata; p++) { |
|
cells[p] = plpCells[address++]; |
|
} |
|
} |
|
|
|
addSymbol(l, cells, samples); |
|
} |
|
|
|
if ((c.m_fefLength > 0) && ((m_frameIdx + 1) % std::max(1, c.m_fefInterval) == 0)) { |
|
addFEF(samples); |
|
} |
|
|
|
m_frameIdx = (m_frameIdx + 1) % c.m_frames; |
|
} |
|
|
|
void Modulator::addP1(std::vector<Cf>& samples) |
|
{ |
|
samples.insert(samples.end(), m_p1.begin(), m_p1.end()); |
|
|
|
if (m_tx2) { |
|
m_tx2->insert(m_tx2->end(), m_p1.begin(), m_p1.end()); |
|
} |
|
} |
|
|
|
// The second group of transmitters' pilot sign (9.2.8) |
|
float Modulator::misoSign(int k, int l) const |
|
{ |
|
const Tables& t = *m_tables; |
|
|
|
if (l < numP2(m_config.m_fftSize)) { |
|
return (k % 6 == 3) ? -1.0f : 1.0f; |
|
} |
|
|
|
if ((k == 0) || (k == t.m_kMax)) { |
|
return (l & 1) ? -1.0f : 1.0f; |
|
} |
|
|
|
if (k % t.m_dx == 0) { |
|
return ((k / t.m_dx) & 1) ? -1.0f : 1.0f; |
|
} |
|
|
|
return 1.0f; |
|
} |
|
|
|
// Frequency interleaving, pilots, IFFT and guard interval (8.5, 9.2, 9.5, 9.7) |
|
void Modulator::addSymbol(int l, const std::vector<Cf>& cells, std::vector<Cf>& samples) |
|
{ |
|
const int n = m_config.m_fftSize; |
|
const int np2 = numP2(n); |
|
const Tables& t = *m_tables; |
|
const bool p2 = l < np2; |
|
const bool fc = !p2 && m_frameClosing && (l == m_lf - 1); |
|
const std::vector<int>& data = p2 ? t.m_p2Data : fc ? t.m_fcData : t.m_data[l % t.m_dy]; |
|
const std::vector<Tables::Pilot>& pilots = p2 ? t.m_p2Pilots : fc ? t.m_fcPilots : t.m_pilots[l % t.m_dy]; |
|
const std::vector<int>& read = p2 ? t.p2Deinterleave(l) : fc ? t.fcDeinterleave(l) : t.dataDeinterleave(l); |
|
const int pn = framePN(l); |
|
const float scale = 5.0f / std::sqrt(27.0f * (t.m_kMax + 1)); |
|
const int ng = guardSamples(n, m_config.m_guard); |
|
auto bin = [n, &t](int k) { return (k - t.m_kMax / 2 + n) % n; }; |
|
|
|
// The cells in carrier order, the frequency interleaver's output |
|
m_carrierCells.assign(data.size(), Cf(0.0f, 0.0f)); |
|
|
|
for (size_t p = 0; p < cells.size(); p++) { |
|
m_carrierCells[read[p]] = cells[p]; |
|
} |
|
|
|
// The first group of transmitters, or the only one, then in MISO the second: each pair of cells a0, a1 as |
|
// -a1*, a0* (9.1), and some pilots inverted |
|
for (int group = 0; group < (m_tx2 ? 2 : 1); group++) |
|
{ |
|
Cf *in = m_fft->in(); |
|
std::fill(in, in + n, Cf(0.0f, 0.0f)); |
|
|
|
for (size_t i = 0; i < data.size(); i++) |
|
{ |
|
if (group == 0) { |
|
in[bin(data[i])] = m_carrierCells[i]; |
|
} else if (i & 1) { |
|
in[bin(data[i])] = std::conj(m_carrierCells[i - 1]); |
|
} else if (i + 1 < data.size()) { |
|
in[bin(data[i])] = -std::conj(m_carrierCells[i + 1]); |
|
} |
|
} |
|
|
|
for (const Tables::Pilot& pilot : pilots) |
|
{ |
|
int r = t.m_w[pilot.m_k] ^ pn; |
|
const float sign = group == 1 ? misoSign(pilot.m_k, l) : 1.0f; |
|
in[bin(pilot.m_k)] = Cf(sign * (r ? -pilot.m_amplitude : pilot.m_amplitude), 0.0f); |
|
} |
|
|
|
m_fft->transform(); |
|
const Cf *out = m_fft->out(); |
|
std::vector<Cf>& to = group == 0 ? samples : *m_tx2; |
|
|
|
for (int i = n - ng; i < n; i++) { |
|
to.push_back(out[i] * scale); |
|
} |
|
|
|
for (int i = 0; i < n; i++) { |
|
to.push_back(out[i] * scale); |
|
} |
|
} |
|
} |
|
|
|
} // namespace dvbt2
|
|
|