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.
440 lines
15 KiB
440 lines
15 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 "lteturbo.h" |
|
|
|
// TS 36.212 Table 5.1.3-3: QPP interleaver parameters for the 188 block sizes |
|
// K = 40..512 step 8, 528..1024 step 16, 1056..2048 step 32, 2112..6144 step 64 |
|
const uint16_t LTETurbo::m_qppF1[188] = { |
|
3, 7, 19, 7, 7, 11, 5, 11, 7, 41, 103, 15, 9, 17, 9, 21, 101, 21, 57, 23, 13, |
|
27, 11, 27, 85, 29, 33, 15, 17, 33, 103, 19, 19, 37, 19, 21, 21, 115, 193, 21, |
|
133, 81, 45, 23, 243, 151, 155, 25, 51, 47, 91, 29, 29, 247, 29, 89, 91, 157, |
|
55, 31, 17, 35, 227, 65, 19, 37, 41, 39, 185, 43, 21, 155, 79, 139, 23, 217, |
|
25, 17, 127, 25, 239, 17, 137, 215, 29, 15, 147, 29, 59, 65, 55, 31, 17, 171, |
|
67, 35, 19, 39, 19, 199, 21, 211, 21, 43, 149, 45, 49, 71, 13, 17, 25, 183, 55, |
|
127, 27, 29, 29, 57, 45, 31, 59, 185, 113, 31, 17, 171, 209, 253, 367, 265, 181, |
|
39, 27, 127, 143, 43, 29, 45, 157, 47, 13, 111, 443, 51, 51, 451, 257, 57, 313, |
|
271, 179, 331, 363, 375, 127, 31, 33, 43, 33, 477, 35, 233, 357, 337, 37, 71, |
|
71, 37, 39, 127, 39, 39, 31, 113, 41, 251, 43, 21, 43, 45, 45, 161, 89, 323, 47, 23, 47, 263 |
|
}; |
|
|
|
const uint16_t LTETurbo::m_qppF2[188] = { |
|
10, 12, 42, 16, 18, 20, 22, 24, 26, 84, 90, 32, 34, 108, 38, 120, 84, 44, 46, |
|
48, 50, 52, 36, 56, 58, 60, 62, 32, 198, 68, 210, 36, 74, 76, 78, 120, 82, 84, |
|
86, 44, 90, 46, 94, 48, 98, 40, 102, 52, 106, 72, 110, 168, 114, 58, 118, 180, |
|
122, 62, 84, 64, 66, 68, 420, 96, 74, 76, 234, 80, 82, 252, 86, 44, 120, 92, |
|
94, 48, 98, 80, 102, 52, 106, 48, 110, 112, 114, 58, 118, 60, 122, 124, 84, |
|
64, 66, 204, 140, 72, 74, 76, 78, 240, 82, 252, 86, 88, 60, 92, 846, 48, 28, |
|
80, 102, 104, 954, 96, 110, 112, 114, 116, 354, 120, 610, 124, 420, 64, 66, |
|
136, 420, 216, 444, 456, 468, 80, 164, 504, 172, 88, 300, 92, 188, 96, 28, 240, |
|
204, 104, 212, 192, 220, 336, 228, 232, 236, 120, 244, 248, 168, 64, 130, 264, |
|
134, 408, 138, 280, 142, 480, 146, 444, 120, 152, 462, 234, 158, 80, 96, 902, |
|
166, 336, 170, 86, 174, 176, 178, 120, 182, 184, 186, 94, 190, 480 |
|
}; |
|
|
|
int LTETurbo::qppIndex(int K) |
|
{ |
|
if ((K >= 40) && (K <= 512) && ((K % 8) == 0)) { |
|
return (K - 40) / 8; |
|
} else if ((K > 512) && (K <= 1024) && ((K % 16) == 0)) { |
|
return 60 + (K - 528) / 16; |
|
} else if ((K > 1024) && (K <= 2048) && ((K % 32) == 0)) { |
|
return 92 + (K - 1056) / 32; |
|
} else if ((K > 2048) && (K <= 6144) && ((K % 64) == 0)) { |
|
return 124 + (K - 2112) / 64; |
|
} else { |
|
return -1; |
|
} |
|
} |
|
|
|
bool LTETurbo::isValidBlockSize(int K) |
|
{ |
|
return qppIndex(K) >= 0; |
|
} |
|
|
|
bool LTETurbo::qppParameters(int K, int& f1, int& f2) |
|
{ |
|
int idx = qppIndex(K); |
|
|
|
if (idx < 0) { |
|
return false; |
|
} |
|
f1 = m_qppF1[idx]; |
|
f2 = m_qppF2[idx]; |
|
return true; |
|
} |
|
|
|
void LTETurbo::interleaver(int K, std::vector<int>& pi) |
|
{ |
|
int f1, f2; |
|
|
|
pi.resize(K); |
|
if (!qppParameters(K, f1, f2)) { |
|
return; |
|
} |
|
for (int i = 0; i < K; i++) |
|
{ |
|
// Use 64-bit to avoid overflow of f2*i*i |
|
int64_t ii = i; |
|
pi[i] = (int) ((f1 * ii + f2 * ii * ii) % K); |
|
} |
|
} |
|
|
|
// Encode one constituent RSC, including termination. |
|
void LTETurboEncoder::rscEncode(const std::vector<uint8_t>& in, const int *pi, |
|
std::vector<uint8_t>& parity, uint8_t tailSys[3], uint8_t tailParity[3]) |
|
{ |
|
int K = (int) in.size(); |
|
int s = 0; |
|
|
|
parity.resize(K); |
|
for (int k = 0; k < K; k++) |
|
{ |
|
int u = pi ? in[pi[k]] : in[k]; |
|
int a = LTETurbo::rscFeedback(s, u); |
|
parity[k] = LTETurbo::rscParity(s, a); |
|
s = LTETurbo::rscNext(s, a); |
|
} |
|
// Termination: input is chosen so the register input is 0 |
|
for (int k = 0; k < 3; k++) |
|
{ |
|
int u = ((s >> 1) & 1) ^ (s & 1); |
|
tailSys[k] = u; |
|
tailParity[k] = LTETurbo::rscParity(s, 0); |
|
s = LTETurbo::rscNext(s, 0); |
|
} |
|
} |
|
|
|
void LTETurboEncoder::encode(const std::vector<uint8_t>& in, |
|
std::vector<uint8_t>& d0, std::vector<uint8_t>& d1, std::vector<uint8_t>& d2) |
|
{ |
|
int K = (int) in.size(); |
|
std::vector<int> pi; |
|
std::vector<uint8_t> z1, z2; |
|
uint8_t x1t[3], z1t[3], x2t[3], z2t[3]; |
|
|
|
LTETurbo::interleaver(K, pi); |
|
rscEncode(in, nullptr, z1, x1t, z1t); |
|
rscEncode(in, pi.data(), z2, x2t, z2t); |
|
|
|
d0.resize(K + 4); |
|
d1.resize(K + 4); |
|
d2.resize(K + 4); |
|
for (int k = 0; k < K; k++) |
|
{ |
|
d0[k] = in[k]; |
|
d1[k] = z1[k]; |
|
d2[k] = z2[k]; |
|
} |
|
// Tail bits multiplexing, TS 36.212 5.1.3.2.2 |
|
d0[K] = x1t[0]; d0[K+1] = z1t[1]; d0[K+2] = x2t[0]; d0[K+3] = z2t[1]; |
|
d1[K] = z1t[0]; d1[K+1] = x1t[2]; d1[K+2] = z2t[0]; d1[K+3] = x2t[2]; |
|
d2[K] = x1t[1]; d2[K+1] = z1t[2]; d2[K+2] = x2t[1]; d2[K+3] = z2t[2]; |
|
} |
|
|
|
LTETurboDecoder::LTETurboDecoder() : |
|
m_K(0) |
|
{ |
|
} |
|
|
|
void LTETurboDecoder::setBlockSize(int K) |
|
{ |
|
if (K != m_K) |
|
{ |
|
m_K = K; |
|
LTETurbo::interleaver(K, m_pi); |
|
m_alpha.resize((K + 4) * 8); |
|
m_gammaSys.resize(K + 3); |
|
m_gammaPar.resize(K + 3); |
|
} |
|
} |
|
|
|
LTETurboDecoder::Trellis::Trellis() |
|
{ |
|
int count[8] = {0}; |
|
|
|
for (int s = 0; s < 8; s++) |
|
{ |
|
for (int u = 0; u < 2; u++) |
|
{ |
|
int a = LTETurbo::rscFeedback(s, u); |
|
int ns = LTETurbo::rscNext(s, a); |
|
m_next[s][u] = ns; |
|
m_gamma[s][u] = 2 * u + LTETurbo::rscParity(s, a); |
|
m_prev[ns][count[ns]] = s; |
|
m_prevGamma[ns][count[ns]] = m_gamma[s][u]; |
|
count[ns]++; |
|
} |
|
} |
|
} |
|
|
|
const LTETurboDecoder::Trellis& LTETurboDecoder::trellis() |
|
{ |
|
static const Trellis trellis; |
|
return trellis; |
|
} |
|
|
|
// Max-log-MAP BCJR for one constituent decoder. Outputs a posteriori LLRs for the K information bits. |
|
// Branch metric for bit b with LLR L is +L/2 if b = 0, -L/2 if b = 1. |
|
// Metrics are normalised relative to state 0, which is reachable at every step. |
|
void LTETurboDecoder::bcjr(const float *sys, const float *apriori, const float *parity, |
|
const float *tailSys, const float *tailParity, float *llrOut) |
|
{ |
|
const int K = m_K; |
|
const Trellis& t = trellis(); |
|
float *alpha = m_alpha.data(); |
|
|
|
for (int k = 0; k < K; k++) |
|
{ |
|
m_gammaSys[k] = 0.5f * (sys[k] + apriori[k]); |
|
m_gammaPar[k] = 0.5f * parity[k]; |
|
} |
|
for (int k = 0; k < 3; k++) |
|
{ |
|
m_gammaSys[K + k] = 0.5f * tailSys[k]; |
|
m_gammaPar[K + k] = 0.5f * tailParity[k]; |
|
} |
|
|
|
// Forward recursion |
|
alpha[0] = 0.0f; |
|
for (int s = 1; s < 8; s++) { |
|
alpha[s] = m_minusInf; |
|
} |
|
for (int k = 0; k < K; k++) |
|
{ |
|
const float *a = &alpha[k * 8]; |
|
float *an = &alpha[(k + 1) * 8]; |
|
const float gs = m_gammaSys[k]; |
|
const float gp = m_gammaPar[k]; |
|
const float g[4] = {gs + gp, gs - gp, -gs + gp, -gs - gp}; |
|
|
|
for (int ns = 0; ns < 8; ns++) |
|
{ |
|
an[ns] = std::max(a[t.m_prev[ns][0]] + g[t.m_prevGamma[ns][0]], |
|
a[t.m_prev[ns][1]] + g[t.m_prevGamma[ns][1]]); |
|
} |
|
const float norm = an[0]; |
|
for (int s = 0; s < 8; s++) { |
|
an[s] -= norm; |
|
} |
|
} |
|
// Termination: register input is forced to 0, so systematic input depends on state |
|
for (int k = K; k < K + 3; k++) |
|
{ |
|
const float *a = &alpha[k * 8]; |
|
float *an = &alpha[(k + 1) * 8]; |
|
const float gs = m_gammaSys[k]; |
|
const float gp = m_gammaPar[k]; |
|
const float g[4] = {gs + gp, gs - gp, -gs + gp, -gs - gp}; |
|
|
|
for (int s = 0; s < 8; s++) { |
|
an[s] = m_minusInf; |
|
} |
|
for (int s = 0; s < 8; s++) |
|
{ |
|
const int u = LTETurbo::rscFeedback(s, 0); |
|
an[t.m_next[s][u]] = std::max(an[t.m_next[s][u]], a[s] + g[t.m_gamma[s][u]]); |
|
} |
|
const float norm = an[0]; |
|
for (int s = 0; s < 8; s++) { |
|
an[s] -= norm; |
|
} |
|
} |
|
|
|
// Backward recursion, ending in state 0 |
|
float beta[8], betaPrev[8]; |
|
beta[0] = 0.0f; |
|
for (int s = 1; s < 8; s++) { |
|
beta[s] = m_minusInf; |
|
} |
|
for (int k = K + 2; k >= K; k--) |
|
{ |
|
const float gs = m_gammaSys[k]; |
|
const float gp = m_gammaPar[k]; |
|
const float g[4] = {gs + gp, gs - gp, -gs + gp, -gs - gp}; |
|
|
|
for (int s = 0; s < 8; s++) |
|
{ |
|
const int u = LTETurbo::rscFeedback(s, 0); |
|
betaPrev[s] = g[t.m_gamma[s][u]] + beta[t.m_next[s][u]]; |
|
} |
|
const float norm = betaPrev[0]; |
|
for (int s = 0; s < 8; s++) { |
|
beta[s] = betaPrev[s] - norm; |
|
} |
|
} |
|
for (int k = K - 1; k >= 0; k--) |
|
{ |
|
const float *a = &alpha[k * 8]; |
|
const float gs = m_gammaSys[k]; |
|
const float gp = m_gammaPar[k]; |
|
const float g[4] = {gs + gp, gs - gp, -gs + gp, -gs - gp}; |
|
float m0 = m_minusInf; |
|
float m1 = m_minusInf; |
|
|
|
for (int s = 0; s < 8; s++) |
|
{ |
|
const float b0 = g[t.m_gamma[s][0]] + beta[t.m_next[s][0]]; |
|
const float b1 = g[t.m_gamma[s][1]] + beta[t.m_next[s][1]]; |
|
betaPrev[s] = std::max(b0, b1); |
|
m0 = std::max(m0, a[s] + b0); |
|
m1 = std::max(m1, a[s] + b1); |
|
} |
|
llrOut[k] = m0 - m1; |
|
const float norm = betaPrev[0]; |
|
for (int s = 0; s < 8; s++) { |
|
beta[s] = betaPrev[s] - norm; |
|
} |
|
} |
|
} |
|
|
|
int LTETurboDecoder::decode(const std::vector<float>& d0, const std::vector<float>& d1, const std::vector<float>& d2, |
|
std::vector<uint8_t>& out, int maxIterations, EarlyStop earlyStop) |
|
{ |
|
const int K = m_K; |
|
const float extrinsicScale = 0.75f; // Compensates for max-log approximation optimism |
|
std::vector<float> sys1(K), sys2(K), par1(K), par2(K); |
|
std::vector<float> apriori1(K, 0.0f), apriori2(K), llr1(K), llr2(K); |
|
float tailSys1[3], tailPar1[3], tailSys2[3], tailPar2[3]; |
|
|
|
out.resize(K); |
|
if ((K == 0) || ((int) d0.size() < K + 4) || ((int) d1.size() < K + 4) || ((int) d2.size() < K + 4)) { |
|
return -1; |
|
} |
|
|
|
for (int k = 0; k < K; k++) |
|
{ |
|
sys1[k] = d0[k]; |
|
sys2[k] = d0[m_pi[k]]; |
|
par1[k] = d1[k]; |
|
par2[k] = d2[k]; |
|
} |
|
// Tail bits demultiplexing, inverse of TS 36.212 5.1.3.2.2 |
|
tailSys1[0] = d0[K]; tailPar1[0] = d1[K]; |
|
tailSys1[1] = d2[K]; tailPar1[1] = d0[K+1]; |
|
tailSys1[2] = d1[K+1]; tailPar1[2] = d2[K+1]; |
|
tailSys2[0] = d0[K+2]; tailPar2[0] = d1[K+2]; |
|
tailSys2[1] = d2[K+2]; tailPar2[1] = d0[K+3]; |
|
tailSys2[2] = d1[K+3]; tailPar2[2] = d2[K+3]; |
|
|
|
for (int iter = 1; iter <= maxIterations; iter++) |
|
{ |
|
bcjr(sys1.data(), apriori1.data(), par1.data(), tailSys1, tailPar1, llr1.data()); |
|
for (int k = 0; k < K; k++) |
|
{ |
|
int j = m_pi[k]; |
|
apriori2[k] = extrinsicScale * (llr1[j] - sys1[j] - apriori1[j]); |
|
} |
|
bcjr(sys2.data(), apriori2.data(), par2.data(), tailSys2, tailPar2, llr2.data()); |
|
for (int k = 0; k < K; k++) |
|
{ |
|
int j = m_pi[k]; |
|
apriori1[j] = extrinsicScale * (llr2[k] - sys2[k] - apriori2[k]); |
|
out[j] = llr2[k] < 0.0f ? 1 : 0; |
|
} |
|
if (earlyStop && earlyStop(out)) { |
|
return iter; |
|
} |
|
} |
|
|
|
return earlyStop ? -maxIterations : maxIterations; |
|
} |
|
|
|
void LTERateMatcher::bufferMap(int D, std::vector<int>& stream, std::vector<int>& index) |
|
{ |
|
// Inter-column permutation pattern for sub-block interleaver, TS 36.212 Table 5.1.4-1 |
|
static const int P[32] = { |
|
0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10, 26, 6, 22, 14, 30, |
|
1, 17, 9, 25, 5, 21, 13, 29, 3, 19, 11, 27, 7, 23, 15, 31 |
|
}; |
|
const int R = (D + 31) / 32; |
|
const int Kpi = R * 32; |
|
const int ND = Kpi - D; |
|
|
|
stream.resize(3 * Kpi); |
|
index.resize(3 * Kpi); |
|
|
|
for (int k = 0; k < Kpi; k++) |
|
{ |
|
int y01 = P[k / R] + 32 * (k % R); |
|
int y2 = (P[k / R] + 32 * (k % R) + 1) % Kpi; |
|
|
|
// Systematic |
|
stream[k] = y01 < ND ? -1 : 0; |
|
index[k] = y01 - ND; |
|
// Interlaced parity streams |
|
stream[Kpi + 2 * k] = y01 < ND ? -1 : 1; |
|
index[Kpi + 2 * k] = y01 - ND; |
|
stream[Kpi + 2 * k + 1] = y2 < ND ? -1 : 2; |
|
index[Kpi + 2 * k + 1] = y2 - ND; |
|
} |
|
} |
|
|
|
int LTERateMatcher::startPosition(int D, int rv) |
|
{ |
|
const int R = (D + 31) / 32; |
|
const int Ncb = 3 * R * 32; |
|
const int c = (Ncb + 8 * R - 1) / (8 * R); |
|
return R * (2 * c * rv + 2); |
|
} |
|
|
|
void LTERateMatcher::match(const std::vector<uint8_t>& d0, const std::vector<uint8_t>& d1, const std::vector<uint8_t>& d2, |
|
int E, int rv, std::vector<uint8_t>& e) |
|
{ |
|
const int D = (int) d0.size(); |
|
std::vector<int> stream, index; |
|
const std::vector<uint8_t> *d[3] = {&d0, &d1, &d2}; |
|
|
|
bufferMap(D, stream, index); |
|
const int Ncb = (int) stream.size(); |
|
const int k0 = startPosition(D, rv); |
|
|
|
e.resize(E); |
|
for (int k = 0, j = 0; k < E; j++) |
|
{ |
|
int pos = (k0 + j) % Ncb; |
|
if (stream[pos] >= 0) { |
|
e[k++] = (*d[stream[pos]])[index[pos]]; |
|
} |
|
} |
|
} |
|
|
|
void LTERateMatcher::dematch(const std::vector<float>& e, int D, int rv, |
|
std::vector<float>& d0, std::vector<float>& d1, std::vector<float>& d2) |
|
{ |
|
const int E = (int) e.size(); |
|
std::vector<int> stream, index; |
|
std::vector<float> *d[3] = {&d0, &d1, &d2}; |
|
|
|
bufferMap(D, stream, index); |
|
const int Ncb = (int) stream.size(); |
|
const int k0 = startPosition(D, rv); |
|
|
|
d0.assign(D, 0.0f); |
|
d1.assign(D, 0.0f); |
|
d2.assign(D, 0.0f); |
|
for (int k = 0, j = 0; k < E; j++) |
|
{ |
|
int pos = (k0 + j) % Ncb; |
|
if (stream[pos] >= 0) { |
|
(*d[stream[pos]])[index[pos]] += e[k++]; |
|
} |
|
} |
|
}
|
|
|