Turbo product codes (TPC) are a form of concatenated codes used as
forward error correcting (FEC) codes. Two or more component block codes, such as systematic
linear block codes, are used to construct TPCs. The TPC decoder achieves near-optimum
decoding of product codes using Chase decoding and the Pyndiah algorithm to perform
iterative soft input, soft output decoding. For a detailed description, see [1] and [2]. This decoder implements
an iterative soft input, soft output 2-D product code decoding, as described in [2], using two Linear Block Codes. The
decoder expects the soft bit log likelihood ratios (LLRs) obtained from digital demodulation
as the input signal.

The TPC decoder accepts either full-length or shortened codes.

TPC Decoding Full-Length Messages

TPC encoded full-length input messages are decoded using specified 2-D TPC code pairs.
Row-wise decoding uses the
(*N*_{C},*K*_{C})
code pair and column-wise decoding uses the
(*N*_{R},*K*_{R})
code pair. The input vector length must be *N*_{R}
× *N*_{C}. To perform the 2-D TPC decoding, the
column vector of the input LLRs, composed of the message and parity bits, is arranged
into an
*N*_{R}-by-*N*_{C}
matrix.

The TPC decoder achieves near-optimum decoding of product codes using Chase decoding
and the Pyndiah algorithm to perform iterative soft input, soft output decoding. Chase
decoding forms a set of possible codewords for each row or column. The Pyndiah algorithm
calculates soft information required for the next decoding step.

**Iterative Soft Input, Soft Output Decoder**

The iterative soft input, soft output decoding, as shown in the block diagram, carries
out two decoding steps for each iteration.

The soft inputs for decoding are **R**(*m*) = **R** +
α(*m*)**W**(*m*).

Iteration loop counter *i* increments from
*i* = 1 to the specified number of iterations.

*m* = `2`

*i* –
`1`

is the decoding step index.

**R** is the received LLR
matrix.

**R**(*m*) is the soft input for the
*m*th decoding step.

**W**(*m*) is the input extrinsic
information for the *m*th decoding step.

*α*(*m*) = [0,0.2,0.3,0.5,0.7,0.9,1,1,
...], where *α* is a weighting factor applied based on the
decoding step index. For higher decoding steps, *α* =
1.

*β*(*m*) = [0.2,0.4,0.6,0.8,1,1, ...],
where *β* is a reliability factor applied based on the
decoding step index. For higher decoding steps, *β* =
1.

**D** contains the decoded
message bits. The output message bits are formed from **D ** by mapping –1 to 0 and +1 to 1,
then reshaping the message block into a column vector.

The output message bits are formed after iterating through the specified number of
iterations, or, if early termination is enabled, after code convergence.

**Early Termination of TPC Decoding**

If early termination is enabled, a code convergence check is performed on the hard
decision of the soft input in each row-wise and column-wise decoding step. Early
termination can be triggered after either the row-wise decoding or column-wise decoding
converges.

The code is converged if, for all rows or all columns,

The syndrome evaluates to zero in the codes (Hamming codes, Extended
Hamming codes, BCH codes, or Extended BCH codes).

The parity check is evaluated to zero in parity check codes.

The reported number of iterations evaluates to the iteration value that is currently
in progress. For example, if the code convergence check is satisfied after row-wise
decoding in the third iteration (after 2.5 decoding steps), then the number of iteration
returned is 3.

TPC Decoding Shortened Messages

TPC encoded shortened input messages are decoded using specified 2-D TPC code pairs.
Row-wise decoding uses the (*N*_{C} –
*K*_{C} +
*S*_{C},
*S*_{C}) code pair and column-wise decoding
uses the (*N*_{R} –
*K*_{R} +
*S*_{R},
*S*_{R}) code pair. The input vector length
must be (*N*_{R} –
*K*_{R} +
*S*_{R}) ×
(*N*_{C}–
*K*_{C} +
*S*_{C}). To perform the 2-D TPC decoding of
shortened messages, the column vector of the input LLRs, composed of the shortened
message and parity bits, is arranged into an
(*N*_{R} –
*K*_{R} +
*S*_{R})-by-(*N*_{C}
– *K*_{C} +
*S*_{C}) matrix.

The TPC decoder processes the received shortened message LLRs similar to full length
codes, with these exceptions: