nrDLSCHDecoder

Apply DL-SCH decoder processing chain

Description

The nrDLSCHDecoder System object™ applies the downlink shared channel (DL-SCH) decoder processing chain to the soft bits corresponding to one or two DL-SCH-encoded transport blocks. The DL-SCH decoding process consists of rate recovery, low-density parity-check (LDPC) decoding, desegmentation, and cyclic redundancy check (CRC) decoding. The object implements the inverse operation of the DL-SCH encoding process specified in TS 38.212 Section 7.2 [1].

To apply the DL-SCH decoder processing chain:

1. Create the nrDLSCHDecoder object and set its properties.

2. Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects?

Creation

Syntax

decDL = nrDLSCHDecoder

decDL = nrDLSCHDecoder(Name,Value)

Description

decDL = nrDLSCHDecoder creates a DL-SCH decoder System object.

decDL = nrDLSCHDecoder(Name,Value) creates the object with properties set by using one or more name-value pairs. Enclose the property name inside quotes, followed by the specified value. Unspecified properties take default values.

Example: For example, nrDLSCHDecoder('MultipleHARQProcesses',true) creates the object and enables multiple hybrid automatic repeat-request (HARQ) processes.

Properties

Unless otherwise indicated, properties are nontunable, which means you cannot change their values after calling the object. Objects lock when you call them, and the release function unlocks them.

If a property is tunable, you can change its value at any time.

For more information on changing property values, see System Design in MATLAB Using System Objects.

MultipleHARQProcesses — Enable multiple HARQ processes

0 or false (default) | 1 or true

Enable multiple HARQ processes, specified as one of these values:

• 0 (false) — The object uses a single HARQ process.

• 1 (true) — The object uses multiple HARQ processes, at most 32.

In both cases, to enable soft combining of retransmissions before LDPC decoding, the object maintains a soft buffer for each HARQ process.

Data Types: logical | double

CBGTransmission — Enable support for CBG-based transmission

0 or false (default) | 1 or true

Since R2025a

Enable support for transmission based on code block groups (CBGs), specified as one of these values:

• 0 (false) — Disable support for CBG-based transmission. The object uses transmission based on transport blocks (TBs).

• 1 (true) — Enable support for CBG-based transmission. The object takes an additional input argument, cbgti, that specifies CBG transmission information used with the current transmission, and returns an additional output argument, cbgerr, that provides CRC error flags per CBGs. If the number of rows in cbgti is 1, the processing is equivalent to the TB-based transmission.

Data Types: logical | double

AutoFlushSoftBuffer — Flush soft buffer automatically

1 or true (default) | 0 or false

Since R2025a

Flush soft buffer automatically, specified as one of these values:

• 1 (true) — The object automatically flushes the soft buffer associated with a transport block on a transport block CRC pass.

• 0 (false) — The object does not flush the soft buffer automatically. The object continues soft-combining any retransmissions for the associated HARQ process.

Note

To flush the soft buffer manually at any time, call the resetSoftBuffer function.

Data Types: logical | double

TargetCodeRate — Target code rate

0.5137 (default) | numeric scalar | 1-by-2 numeric vector

Target code rate, specified as a numeric scalar or a 1-by-2 numeric vector. The values must be in the interval (0, 1). The default value corresponds to 526/1024. If you specify TargetCodeRate as a scalar, the object applies scalar expansion when processing two transport blocks. To specify different target code rates for each transport block, specify TargetCodeRate as a vector.

Tunable: Yes

Data Types: double

TransportBlockLength — Length of decoded transport block

5120 (default) | positive scalar integer | 1-by-2 integer vector

Length of decoded transport block, or transport blocks, in bits, specified as a positive scalar integer or a 1-by-2 integer vector. If you specify TransportBlockLength as a scalar, the object applies scalar expansion when processing two transport blocks. To specify a different length for the decoded transport blocks, specify TransportBlockLength as a vector.

Tunable: Yes

Data Types: double

LimitedBufferSize — Limited buffer size

25344 (default) | positive integer

Limited buffer size used for rate recovery, specified as a positive integer. The default value corresponds to 384×66, which is the maximum coded length of a code block. The default value implies no limit on the buffer size.

Tunable: Yes

Data Types: double

MaximumLDPCIterationCount — Maximum LDPC decoding iterations

12 (default) | positive integer

Maximum LDPC decoding iterations, specified as a positive integer. Since early termination is enabled, decoding stops once parity-checks are satisfied. In this case, fewer iterations take place than the maximum specified by this argument.

Data Types: double

LDPCDecodingAlgorithm — LDPC decoding algorithm

'Belief propagation' (default) | 'Layered belief propagation' | 'Normalized min-sum' | 'Offset min-sum'

LDPC decoding algorithm, specified as one of these values:

• 'Belief propagation' — Use this option to specify the belief-passing or message-passing algorithm.

• 'Layered belief propagation' — Use this option to specify the layered belief-passing algorithm, which is suitable for quasi-cyclic parity-check matrices (PCMs).

• 'Normalized min-sum' — Use this option to specify the layered belief propagation algorithm with normalized min-sum approximation.

• 'Offset min-sum' — Use this option to specify the layered belief propagation algorithm with offset min-sum approximation.

For more information on these algorithms, see LDPC Decoding Algorithms.

Data Types: char | string

ScalingFactor — Scaling factor for normalized min-sum decoding

0.75 (default) | real scalar in the range (0, 1]

Scaling factor for normalized min-sum decoding, specified as a real scalar in the range (0, 1].

Dependencies

To enable this property, set the LDPCDecodingAlgorithm property to 'Normalized min-sum'.

Data Types: double

Offset — Offset for offset min-sum decoding

0.5 (default) | nonnegative finite real scalar

Offset for offset min-sum decoding, specified as a nonnegative finite real scalar.

Dependencies

To enable this property, set the LDPCDecodingAlgorithm property to 'Offset min-sum'.

Data Types: double

UniformCellOutput — Enable cell output format

0 (default) | 1

Since R2024a

Enable cell output format, irrespective of the number of codewords, specified as one of these logical values:

• 0 (false) — This option corresponds to the default behavior of the object in which the trblk output is returned as a column vector for a single codeword or as a cell array for two codewords.

• 1 (true) — The object returns trblk as a cell array irrespective of the number of codewords.

Data Types: logical | double

TransportBlockSizesPerProcess — Transport block sizes per each HARQ process

1-by-2 array of nonnegative integers | 32-by-2 array of nonnegative integers

Since R2025a

Transport block sizes per each HARQ process, returned as one of these values:

• 1-by-2 array of nonnegative integers for a single HARQ process (MultipleHARQProcesses = false)

• 32-by-2 array of nonnegative integers for multiple HARQ processes (MultipleHARQProcesses = true)

The array rows correspond to HARQ processes. The two array columns correspond to the two possible transport blocks.

Data Types: double

Usage

Syntax

trblk = decDL(softbits,mod,nLayers,rv)

trblk = decDL(___,harqID)

[trblk,blkerr] = decDL(___)

[trblk,blkerr,cbgerr] = decDL(___,cbgti)

Description

trblk = decDL(softbits,mod,nLayers,rv) applies the DL-SCH decoder processing chain to the input softbits and returns the decoded bits. mod specifies the modulation scheme. nLayers specifies the number of transmission layers. rv specifies the redundancy version of the transmission.

trblk = decDL(___,harqID) specifies the HARQ process number harqID used with the current transmission in addition to the input arguments in the previous syntax. To use this syntax, set the MultipleHARQProcesses property to true. When the property is set to false, the object uses HARQ process number 0.

When the object receives codewords with different redundancy version for an individual HARQ process, the object uses soft buffer state retention to enable soft combining of retransmissions. When you enable multiple HARQ processes, the object maintains independent buffers for each process.

Upon successful decoding of the input, the object automatically resets the soft buffer for a HARQ process. To reset the soft buffer manually, call the resetSoftBuffer function.

[trblk,blkerr] = decDL(___) returns an error flag, using the input arguments in any of the previous syntaxes. A value of 1 in blkerr indicates an error during transport block decoding.

[trblk,blkerr,cbgerr] = decDL(___,cbgti) specifies the CBG transmission information used with the current transmission in addition to the input arguments in any of the previous syntaxes. The object returns also the CRC error flags per CBGs, cbgerr. A value of 1 in cbgerr indicates that the corresponding CBG in the corresponding transport block failed the CRC check in the current transmission. The CRC pass is assumed for CBGs not transmitted in the current transmission. To use this syntax, set the CBGTransmission property to true. (since R2025a)

Input Arguments

softbits — Approximate LLR soft bits

real column vector | cell array of two real column vectors

Approximate log-likelihood ratio (LLR) soft bits, corresponding to one or two DL-SCH-encoded transport blocks, specified as a real column vector or a cell array of two real column vectors.

Data Types: single | double

mod — Modulation scheme

'QPSK' | '16QAM' | '64QAM' | '256QAM' | '1024QAM' | string array | cell array of character vectors

Modulation scheme, specified as 'QPSK', '16QAM', '64QAM', '256QAM', '1024QAM', a string array, or cell array of character vectors. This modulation scheme determines the modulation type and number of bits used per modulation symbol. For two transport blocks, the modulation scheme applies to both blocks. Alternatively, you can specify different modulation schemes for each transport block by using a string array or a cell array of character vectors.

Modulation Scheme	Number of Bits Per Symbol
'QPSK'	2
'16QAM'	4
'64QAM'	6
'256QAM'	8
'1024QAM'	10

Data Types: char | string

nLayers — Number of transmission layers

integer from 1 to 8

Number of transmission layers, specified as an integer from 1 to 8. For nLayers > 4, the object expects two encoded transports blocks as input.

Data Types: double

rv — Redundancy version

integer from 0 to 3 | 1-by-2 vector of integers from 0 to 3

Redundancy version, specified as one of these options:

• Integer from 0 to 3 — Use this option to specify the redundancy version for a single encoded transport block.

• 1-by-2 vector of integers from 0 to 3 — Use this option to specify the redundancy version for two encoded transport blocks.

Data Types: double

harqID — HARQ process number

0 (default) | integer from 0 to 31

HARQ process number, specified as an integer from 0 to 31. To specify a value other than 0, set the MultipleHARQProcesses object property to true.

Data Types: double

cbgti — CBG transmission information

N-by-1 or N-by-2 array of binary values

Since R2025a

CBG transmission information used in the current transmission, specified as an N-by-1 or N-by-2 binary array. N is the maximum number of CBGs defined by the higher-layer parameter maxCodeBlockGroupsPerTransportBlock. Alternatively, N can also be 1, in which case the object uses TB-based transmission. Array values 1 and 0 indicate whether the corresponding CBG in the corresponding transport block is present or absent in the current transmission, respectively.

The array columns correspond to transport blocks. If you specify an N-by-1 column vector in case of two transport blocks (nLayers > 4), the object applies the same CBG information to both transport blocks. If you specify an N-by-2 array in case of one transport block (nLayers <= 4), the object ignores the second column.

Note

To use this argument, set the CBGTransmission property to true.

Data Types: double

Output Arguments

trblk — Decoded DL-SCH transport blocks

binary column vector | cell array of two binary column vectors

Decoded DL-SCH transport blocks, returned as a binary column vector or cell array of two binary column vectors. The TransportBlockLength property specifies the length of the column vectors.

blkerr — Result of DL-SCH transport block decoding

logical scalar | logical vector

Result of DL-SCH transport block decoding for each transport block, returned as a logical scalar or logical vector of length 2. A value of 1 in blkerr indicates an error during transport block decoding.

Data Types: logical

cbgerr — CRC error per CBG

N-by-1 or N-by-2 logical array

Since R2025a

CRC error per CBG, returned as an N-by-1 or N-by-2 logical array. N is the number of rows in the cbgti input. Array values 1 and 0 indicate whether the corresponding CBG in the corresponding transport block has failed or passed the CRC check in the current transmission, respectively.

For one transport block (nLayers <= 4), cbgerr has the same size as cbgti. For two transport blocks (nLayers > 4), cbgerr is of size N-by-2, irrespective of the size of cbgti.

Note

To use this argument, set the CBGTransmission property to true.

Data Types: double

Object Functions

To use an object function, specify the System object as the first input argument. For example, to release system resources of a System object named obj, use this syntax:

release(obj)

Specific to nrDLSCHDecoder

resetSoftBuffer	Reset soft buffer for HARQ process in UL-SCH or DL-SCH decoder
info	DL-SCH or UL-SCH decoding status information

Common to All System Objects

step	Run System object algorithm
clone	Create duplicate System object
isLocked	Determine if System object is in use
release	Release resources and allow changes to System object property values and input characteristics
reset	Reset internal states of System object

Examples

Connect DL-SCH Encoder and Decoder Back to Back

Generate a random sequence of binary values corresponding to one transport block of length 5120.

trBlkLen = 5120;
trBlk = randi([0 1],trBlkLen,1,'int8');

Create and configure a DL-SCH encoder System object with the specified target code rate.

targetCodeRate = 567/1024;
encDL = nrDLSCH;
encDL.TargetCodeRate = targetCodeRate;

Load the transport block into the DL-SCH encoder.

setTransportBlock(encDL,trBlk);

Call the encoder with 64-QAM modulation scheme, 1 transmission layer, an output length of 10,240 bits, and redundancy version 0. The encoder applies the DL-SCH processing chain to the transport block loaded into the object.

mod = '64QAM';
nLayers = 1;
outlen = 10240;
rv = 0;
codedTrBlock = encDL(mod,nLayers,outlen,rv);

Create and configure a DL-SCH decoder System object.

decDL = nrDLSCHDecoder;
decDL.TargetCodeRate = targetCodeRate;
decDL.TransportBlockLength = trBlkLen;

Call the DL-SCH decoder on the soft bits representing the encoded transport block. Use the configuration parameters specified for the encoder. The error flag in the output indicates that the block decoding does not have errors.

rxSoftBits = 1.0 - 2.0*double(codedTrBlock);
[decbits,blkerr] = decDL(rxSoftBits,mod,nLayers,rv)

decbits = 5120×1 int8 column vector

   1
   1
   0
   1
   1
   0
   0
   1
   1
   1
   0
   1
   1
   0
   1
      ⋮

blkerr = logical
   0

Obtain decoding status information.

decoderInfo = info(decDL)

decoderInfo = struct with fields:
                 HARQID: 0
    TransportBlockError: 0
         CodeBlockError: {[0]}
      SoftBufferFlushed: 1

Verify that the transmitted and received message bits are identical.

isequal(decbits,trBlk)

ans = logical
   1

Algorithms

LDPC Decoding Algorithms

The nrDLSCHDecoder object supports these four LDPC decoding algorithms.

Belief Propagation Decoding

The implementation of the belief propagation algorithm is based on the decoding algorithm presented in [2]. For transmitted LDPC-encoded codeword, c, where $$c=(c_0,c_1,\mathrm{...},c_{n-1})$$, the input to the LDPC decoder is the log-likelihood ratio (LLR) value $$L(c_i)=\log \left(\frac{\mathrm{Pr}(c_i=0|\text{channel output for }{c}_i)}{\mathrm{Pr}(c_i=1|\text{channel output for }{c}_i)}\right)$$.

In each iteration, the key components of the algorithm are updated based on these equations:

$$L(r_{ji})=2\text{atanh}\left({\displaystyle \prod _{i^{\prime }\in V_j\backslash i}\tanh \left(\frac{1}{2}L(q_{i^{\prime }j})\right)}\right)$$,

$$L(q_{ij})=L(c_i)+{\displaystyle \sum _{j^{\prime }\in C_i\backslash j}L(r_{j^{\prime }i})}$$, initialized as $$L(q_{ij})=L(c_i)$$ before the first iteration, and

$$L(Q_i)=L(c_i)+{\displaystyle \sum _{j^{\prime }\in C_i}L(r_{j^{\prime }i})}$$.

At the end of each iteration, $$L(Q_i)$$ is an updated estimate of the LLR value for the transmitted bit $$c_i$$. The value $$L(Q_i)$$ is the soft-decision output for $$c_i$$. If $$L(Q_i)\le 0$$, the hard-decision output for $$c_i$$ is 1. Otherwise, the output is 0.

Index sets $$C_i\backslash j$$ and $$V_j\backslash i$$ are based on the parity-check matrix (PCM). Index sets $$C_i$$ and $$V_j$$ correspond to all nonzero elements in column i and row j of the PCM, respectively.

This figure highlights the computation of these index sets in a given PCM for i = 5 and j = 3.

To avoid infinite numbers in the algorithm equations, atanh(1) and atanh(-1) are set to 19.07 and –19.07, respectively. Due to finite precision, MATLAB^® returns 1 for tanh(19.07) and –1 for tanh(–19.07).

The decoding terminates when all parity checks are satisfied ($$H{c}^{\text{T}}=0$$) or after MaximumLDPCIterationCount number of iterations.

Layered Belief Propagation Decoding

The implementation of the layered belief propagation algorithm is based on the decoding algorithm presented in [3], Section II.A. The decoding loop iterates over subsets of rows (layers) of the PCM. For each row, m, in a layer and each bit index, j, the implementation updates the key components of the algorithm based on these equations:

(1) $$L(q_{mj})=L(q_j)-R_{mj}$$,

(2) $$A_{mj}={\displaystyle \sum _{\begin{array}{c}n \in N\left(m\right)\\ n\ne j\end{array}}\text{ψ}(L(q_{mn}))}$$,

(3) $$s_{mj}={\displaystyle \prod _{\begin{array}{c}n \in N\left(m\right)\\ n\ne j\end{array}}\text{sign}(L(q_{mn}))}$$,

(4) $$R_{mj}=-s_{mj}\text{ψ}(A_{mj})$$, and

(5) $$L(q_j)=L(q_{mj})+R_{mj}$$.

For each layer, the decoding equation (5) works on the combined input obtained from the current LLR inputs $$L(q_{mj})$$ and the previous layer updates $$R_{mj}$$.

Because only a subset of the nodes is updated in a layer, the layered belief propagation algorithm is faster compared to the belief propagation algorithm. To achieve the same error rate as attained with belief propagation decoding, use half the number of decoding iterations when using the layered belief propagation algorithm.

Normalized Min-Sum Decoding

The implementation of the normalized min-sum decoding algorithm follows the layered belief propagation algorithm with equation (2) replaced by

$$A_{mj}=\underset{\begin{array}{c}n \in N\left(m\right)\\ n\ne j\end{array}}{\min }(\left|L(q_{mn}) \right|\cdot \alpha )$$,

where α is in the range (0, 1] and is the scaling factor specified by ScalingFactor. This equation is an adaptation of equation (4) presented in [4].

Offset Min-Sum Decoding

The implementation of the offset min-sum decoding algorithm follows the layered belief propagation algorithm with equation (2) replaced by

$$A_{mj} = \max (\underset{\begin{array}{c}n \in N\left(m\right)\\ n\ne j\end{array}}{\min } (\left|L\left(q_{mn}\right)\right|- \beta ), 0)$$,

where β ≥ 0 and is the offset specified by Offset. This equation is an adaptation of equation (5) presented in [4].

References

[1] 3GPP TS 38.212. “NR; Multiplexing and channel coding.” 3rd Generation Partnership Project; Technical Specification Group Radio Access Network.

[2] Gallager, Robert G. Low-Density Parity-Check Codes, Cambridge, MA, MIT Press, 1963.

[3] Hocevar, D.E. "A reduced complexity decoder architecture via layered decoding of LDPC codes." In IEEE Workshop on Signal Processing Systems, 2004. SIPS 2004. dois: 10.1109/SIPS.2004.1363033

[4] Chen, Jinghu, R.M. Tanner, C. Jones, and Yan Li. "Improved min-sum decoding algorithms for irregular LDPC codes." In Proceedings. International Symposium on Information Theory, 2005. ISIT 2005. doi: 10.1109/ISIT.2005.1523374

Extended Capabilities

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

• The nlayers input argument must be compile-time constant. For example, include {coder.Constant(nlayers)} in the -args value of the codegen function. For more information, see the coder.Constant (MATLAB Coder) class.

• See also System Objects in MATLAB Code Generation (MATLAB Coder).

GPU Arrays

Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™. (since R2025a)

The nrDLSCHDecoder function fully supports GPU arrays. To run the function on a GPU, specify the input data as a gpuArray (Parallel Computing Toolbox). For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Version History

Introduced in R2019a

R2025a: Enable support for CBG-based transmission

The nrDLSCHDecoder object adds support for CBG-based transmission. To enable this support, set the CBGTransmission object property to true, then call the object with additional CBG transmission-related input and output arguments.

R2025a: Obtain transport block sizes and decoding information, and control flushing of soft buffer

• Use the TransportBlockSizesPerProcess read-only property to obtain the transport block sizes per each HARQ process.

• Call the info object function to obtain decoding status information associated with the last call of the nrDLSCHDecoder object.

• Disable the automatic flushing of the soft buffer associated with a transport block on a transport block CRC pass by setting the AutoFlushSoftBuffer property to false. In previous releases, the object automatically flushes these soft buffers.

R2025a: GPU array support

The nrDLSCHDecoder System object adds support for GPU arrays. For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

R2024b: LimitedBufferSize property becomes tunable

The LimitedBufferSize property is now tunable.

R2024a: Configure format of outputs

To return the trblk output as a cell array irrespective of the number of codewords, set the UniformCellOutput property to true.

R2023a: Release 17 updates for 1024QAM and 32 HARQ processes

The object now supports 1024QAM modulation and up to 32 HARQ processes.