SEGMENTATION MECHANISM FOR A BLOCK ENCODER

Description

Background of the invention

[0001] The invention relates to methods and equipment for block encoders. As is well known, block encoders are frequently used for error correction. An example of a block encoder is a so-called turbo (en)coder, as disclosed in reference 1.

[0002] Figure 1 is a block chart of a turbo encoder TE which is connected to a corresponding turbo decoder TD via a (transmission) channel. A typical turbo encoder conveys the original information directly to the channel. These bits are called systematic bits. Additionally, the turbo encoder adds redundancy (parity) with simple encoders 1 and 2, the latter of which is preceded by an interleaver P, which permutes the bits of the original information. However, details of the block encoder are not relevant for understanding the invention, and reference is made to relevant literature.

[0003] Unlike streaming encoders, block encoders process one or more data blocks at a time. An input data block whose size exceeds the block size of the block encoder must be divided into smaller segments such that no segment is larger than the block size of the block encoder. This is why block encoders are particularly suitable for applications with a fixed input block size. A problem with block encoders is that they do not easily lend themselves to applications having a variable (dynamic) input block size. In other words, what to do with the last few segments of the input data block, remains an open question.

[0004] A straightforward solution would be to fill the segment of the input data block to the block size of the block encoder. Assuming a block size of 8 kilobits (kb), a 14-kb input data block would be divided into a first segment of 8 kb and second (last) segment with a net size of 6 kb and 2 kb of fill (padding) bits. A benefit of this straightforward solution is that the block encoder does not have to adapt to varying input block sizes. Such a solution is disclosed in "Parameter for segmentation in channel coding", TSG-RAN Working Group 1 (Radio) meeting #3, Nynäshamn, Sweden, March 22 - 26, 1999.

Disclosure of the invention

[0005] An object of the invention is to provide a mechanism for using block encoders with applications having a variable (dynamic) input block size. The mechanism should be generic in order to be applicable to a wide variety of block encoders.

[0006] This object is achieved with a method and equipment which are characterized by what is disclosed in the attached independent claims. Preferred embodiments of the invention are disclosed in the attached dependent claims.

[0007] The invention is based on the idea that for an input data block whose size exceeds the block size of the block encoder:

1) before coding is started, the size of the input data block is determined; and

2) the input data block is divided into segments of approximately equal size such that no segment is larger than the block size of the block encoder.

[0008] According to a preferred embodiment of the invention, the input data block is divided into the least possible number of segments. In other words, the segments are as large as possible.

[0009] According to an alternative example, the input data block is divided into 2ⁿ segments where n is a positive integer.

[0010] According to yet another preferred embodiment of the invention, if dividing the input data block produces a last segment which is shorter than the remaining segments, the input data block or the last segment is padded with a few fill bits until the length of the last segment equals that of the remaining segments. However, in contrast to the straightforward solution, the last segment is not padded to the full block size of the block encoder (unless the remaining segments happen to be of that size too).

Brief description of the drawings

[0011] The invention will be described in more detail by means of preferred embodiments with reference to the appended drawing wherein:

Figure 1 is a block chart of a turbo encoder; and

Figure 2 illustrates dividing an input data block to a number of segments for the turbo encoder.

Detailed description of the invention

[0012] Various embodiments of the invention will be described in connection with a turbo encoder, an example of which is disclosed in reference 1. However, details of the turbo encoder, or any other encoder, are not relevant for understanding the invention.

[0013] Implementing a turbo encoder (and the corresponding decoder) can be facilitated by limiting the length of the coding block. A reasonable value for the length of the coding block is 8192 bits including the user data, a possible error detection field (CRC) and the termination. The following naming conventions will be used:

N_TAIL = the number of termination bits

T_DELAY (seconds) = the length of the user data block

R_DATA (bits per second) = the user data rate of the service

N_EXTRA = the number of other bits added to the original user data (CRC etc.)

L_CB = max length of the coding block.

The following condition has to be satisfied:

[0014] If this condition is not satisfied the data to be encoded must be segmented so that each separate segment satisfies the condition. The number of segments N_S has to satisfy the condition:

[0015] It is preferable to choose the smallest N_S satisfying the inequality [2]. N_S can be calculated from:

[0016] It may happen that all the encoding blocks do not end up being of the same length, i.e. that (R_DATA* T_DELAY + N_EXTRA) /N_S is not an integer. In such a case, there are at least two possible solutions, which will be called algorithms A and B. In algorithm A, the last segment is allowed to have a different length than the other segments. In algorithm B, a number N_FILL of fill bits (e.g. zeroes) are added to the input data so that (R_DATA * T_DELAY + N_EXTRA + N_FILL) / N_S is the smallest possible integer. (Alternatively, the fill bits can be appended to the last segment after segmentation.)

Algorithm A

[0017] Algorithm A allows the last segment to be shorter than the other segments. Algorithm A uses the following Inputs:

R_DATA = the user data rate (bits per second)

T_DELAY= encoding user data block length (seconds)

N_EXTRA = extra data to be appended to the user data before encoding (bits)

N_TAIL = number of tail bits to be appended to the encoding blocks

[0018] Algorithm A produces the following outputs:

N_S = number of segments

N_TB = number of bits in the turbo encoder input blocks except the last one

N_{LAST_TB} = number of bits in the last turbo encoder input block

[0019] In algorithm A the following computations will be performed:

Let N_S = round_up((R_DATA* T_DELAY + N_EXTRA) / (L_CB - N_TAIL))

Let N_TB = round_up((R_DATA * T_DELAY + N_EXTRA) l N_S) + N_TAIL;

Let N_REM = remainder of (R_DATA * T_DELAY + N_EXTRA) / N_S;

If N_REM is not equal to zero then N_{LAST_TB} = N_TB - N_S + N_REM else N_{LAST_TB} = N_TB. End.

[0020] If algorithm A is used, an adaptive turbo interleaver is needed since the last input segment to the turbo encoder may be shorter than the others. The number of systematic bits in the output of the encoder is

[0021] Thus there are no additional bits other than the ones due to the termination of each segment.

Algorithm B

[0022] As shown in Figure 2, in algorithm B all input segments to the turbo encoder will be of equal size. The inputs to algorithm B are:

R_DATA = the user data rate (bits per second)

T_DELAY = encoding user data block length (seconds)

N_EXTRA = extra data to be appended to the user data before encoding (bits)

N_TAIL = number of tail bits to be appended to the encoding blocks

[0023] The outputs from algorithm B are:

N_S = number of segments

N_TB = number of bits in the turbo encoder input blocks

N_FILL = number of fill bits (e.g. zero) in the last turbo encoder input block

[0024] In algorithm B, the following computations will be performed:

Let N_S = round_up((R_DATA * T_DELAY + N_EXTRA) / (L_CB - N_TAlL))

Let N_TB = round_up ((R_DATA * T_DELAY + N_EXTRA) / N_S) + N_TAlL

Let N_REM = remainder of (R_DATA * T_DELAY + N_EXTRA) / N_S

If N_REM # 0 then insert N_FILL = (N_S - N_REM) zero bits to the end of the input data else N_FILL = 0.

[0025] All input segments to the turbo encoder are of equal size and therefore the same turbo interleaver can be used for all segments. In this case the number of systematic bits over an entire channel interleaving block at the output of the turbo encoder is:

[0026] Thus there may be some additional bits other than the termination bits.

Modification to algorithms A and B

[0027] In the above algorithms A and B, the length of input segment to the turbo encoder is maximised by choosing the smallest possible number of segments N_S. In some cases it may be preferable to use a number of segments N_S which is a power of 2, but this will shorten the input segments to the turbo encoder. In this case, the first step of the above algorithms A and B would be replaced by the following three steps:

Let n_s = round_up ((R_DATA * T_DELAY + N_EXTRA) / (L_CB - N_TAIL));

Let m = round_up (log₂n_s);

Let N_s = 2^m.

References:

[0028] 

1. C. Berrou, A. Glavieux, P. Thitimajshima: Near Shannon limit error-correcting coding and decoding: Turbo-codes, IEEE International Conference on Communications, ICC 1993, Geneva, Switzerland 23-26 May, 1993, Vol. 2, pp. 1064-1070.

Claims

1. A method for segmenting an input data block (IDB) with a segmentation device, to process the input data block with a block encoder (TE), said block encoder being capable of processing consecutive coding blocks (CB) whose size has an upper limit (L_CB) which is smaller than the size of the input data block (IDB);
wherein the method comprises the following steps performed by the segmentation device:

- determining the length of the input data block (IDB) before encoding any of its data with said block encoder (TE);

- calculating the size for a plurality of segments (S₁ ... S_N), wherein no segment is larger than said upper limit (L_CB) ;

- dividing the input data block (IDB) to the plurality of segments (S₁ ... S_N); and

- applying each segment (S₁ ... S_N) to said block encoder (TE);

- wherein the calculation of the size uses the following inputs:

R_DATA = user data rate in bits per second;

T_DELAY =encoding user data block length in seconds;

N_EXTRA = extra data bits to be appended to the user data block before encoding;

N_TAIL = number of tail bits to be appended to the encoding blocks

- and wherein the calculation of the size produces the following outputs:

N_S = number of segments;

N_TB = number of bits in each segment;

N_FILL = number of fill bits for padding the input data block or the last segment;

- and wherein the following computations are performed:

N_S = round_up ((R_DATA * T_DELAY + N_EXTRA) / (L_CB - N_TAIL)) ;

N_TB round_up ((R_DATA * T_DELAY + N_EXTRA) / N_S) + N_TAIL ;

N_FILL = (N_S - N_REM) if N_REM ≠ 0; else N_FILL = 0,
wherein

N_REM = remainder of (R_DATA * T_DELAY + N_EXTRA) / N_S.

2. A segmentation device for segmenting an input data block (IDB) for processing with a block encoder (TE), said block encoder being capable of processing consecutive coding blocks (CB) whose size has an upper limit (L_CB) which is smaller than the size of the input data block (IDB);
wherein the segmentation device is arranged to:

- determine the length of the input data block (IDB) before applying any of its data to said block encoder (TE);

- calculate the size for a plurality of segments (S₁ ... S_N), wherein no segment is larger than said upper limit (L_CB);

- divide the input data block (IDB) to the plurality of segments (S₁ ... S_N) ; and to

- apply each segment (S₁ ... S_N) to said block encoder (TE);

- wherein the calculation of the size uses the following inputs:

R_DATA = user data rate in bits per second;

T_DELAY = encoding user data block length in seconds;

N_EXTRA = extra data bits to be appended to the user data block before encoding;

N_TAIL = number of tail bits to be appended to the encoding blocks

- and wherein the calculation of the size produces the following outputs:

N_S = number of segments;

N_TB = number of bits in each segment;

N_FILL = number of fill bits for padding the input data block or the last segment;

- and wherein the following computations are performed:

N_S = round_up ((R_DATA T_DELAY + N_EXTRA) / (L_CB - N_TAIL));

N_TB = round_up ((R_DATA * T_DELAY + N_EXTRA) / N_S) + N_TAIL ;

N_FILL = (N - N_REM) if N_REM ≠ 0; else N_FILL = 0,
wherein

N_REM = remainder of (R_DATA * T_DELAY + N_EXTRA) / N_S.

3. A block encoder (TE), wherein the block encoder comprises a segmentation device according to claim 2.

Ansprüche

1. Verfahren zum Segmentieren eines Eingangsdatenblocks (IDB) mit einer Segmentierungseinrichtung, um den Eingangsdatenblock mit einem Blockcodierer (TE) zu verarbeiten, wobei der Blockcodierer in der Lage ist, aufeinanderfolgende Codierblöcke (CB) zu verarbeiten, deren Größe eine Obergrenze (L_CB) aufweist, die kleiner ist als die Größe des Eingangsdatenblocks (IDB);
wobei das Verfahren die folgenden Schritte umfasst, die durch die Segmentierungseinrichtung durchgeführt werden:

- Bestimmen der Länge des Eingangsdatenblocks (IDB) vor dem Codieren beliebiger seiner Daten mit dem Blockcodierer (TE);

- Berechnen der Größe für mehrere Segmente (S₁ ... S_N), wobei kein Segment größer ist als die Obergrenze (L_CB);

- Unterteilen des Eingangsdatenblocks (IDB) in die mehreren Segmente (S₁ ... S_N) und

- Anwenden jedes Segments (S₁ ... S_N) auf den Blockcodierer (TE);

- wobei die Berechnung der Größe die folgenden Eingaben verwendet:

R_DATA = Benutzerdatenrate in Bits pro Sekunde;

T_DELAY = codierende Länge des Benutzerdatenblocks in Sekunden;

N_EXTRA = Extradatenbits zum Anhängen an den Benutzerdatenblock vor dem Codieren;

N_TAIL = Anzahl von Tail-Bits zum Anhängen an die codierenden Blöcke

- und wobei die Berechnung der Größe die folgenden Ausgaben erzeugt:

N_S = Anzahl von Segmenten;

N_TB = Anzahl von Bits in jedem Segment;

N_FILL = Anzahl von Füllbits zum Stopfen des Eingangsdatenblocks oder des letzten Segments;

- und wobei die folgenden Berechnungen durchgeführt werden:

N_S = round_up ((R_DATA * T_DELAY + N_EXTRA) / (L_CB - N_TAIL)) ;

N_TB = round_up ((R_DATA * T_DELAY + N_EXTRA) / N_S) + N_TAIL;

N_FILL = (N_S - N_REM), falls N_REM ≠ 0; sonst N_FILL = 0,
wobei

N_REM = remainder of (R_DATA * T_DELAY + N_EXTRA) / Ns.

2. Segmentierungseinrichtung zum Segmentieren eines Eingangsdatenblocks (IDB) zum Verarbeiten mit einem Blockcodierer (TE), wobei der Blockcodierer in der Lage ist, aufeinanderfolgende Codierblöcke (CB) zu Verarbeiten, deren Größe eine Obergrenze (L_CB) aufweist, die kleiner ist als die Größe des Eingangsdatenblocks (IDB);
wobei die Segmentierungseinrichtung ausgelegt ist zum:

- Bestimmen der Länge des Eingangsdatenblocks (IDB) vor dem Codieren beliebiger seiner Daten mit dem Blockcodierer (TE);

- Berechnen der Größe für mehrere Segmente (S₁ ... S_N), wobei kein Segment größer ist als die Obergrenze (L_CB);

- Unterteilen des Eingangsdatenblocks (IDB) in die mehreren Segmente (S₁ ... S_N) und

- Anwenden jedes Segments (S₁ ... S_N) auf den Blockcodierer (TE);

- wobei die Berechnung der Größe die folgenden Eingaben verwendet:

R_DATA = Benutzerdatenrate in Bits pro Sekunde;

T_DELAY = codierende Länge des Benutzerdatenblocks in Sekunden;

N_EXTRA = Extradatenbits zum Anhängen an den Benutzerdatenblock vor dem Codieren;

N_TAIL = Anzahl von Tail-Bits zum Anhängen an die codierenden Blöcke

- und wobei die Berechnung der Größe die folgenden Ausgaben erzeugt:

N_S = Anzahl von Segmenten;

N_TB = Anzahl von Bits in jedem Segment;

N_FILL = Anzahl von Füllbits zum Stopfen des Eingangsdatenblocks oder des letzten Segments;

- und wobei die folgenden Berechnungen durchgeführt werden:

N_S = round_up((R_DATA * T_DELAY + N_EXTRA) / (L_CB - N_TAIL)) ;

N_TB = round_up((R_DATA * T_DELAY + N_EXTRA) / N_S) + N_TAIL;

N_FILL = (N_S - N_REM), falls N_REM ≠ 0; sonst N_FILL = 0,
wobei

N_REM = remainder of (R_DATA * T_DELAY + N_EXTRA) / Ns.

3. Blockcodierer (TE), wobei der Blockcodierer eine Segmentierungseinrichtung nach Anspruch 2 umfasst.

Revendications

1. Un procédé de segmentation d'un bloc de données d'entrée (IDB) avec un dispositif de segmentation destiné à traiter le bloc de données d'entrée avec un codeur de blocs (TE), ledit codeur de blocs étant capable de traiter des blocs de codage consécutifs (CB) dont la taille possède une limite supérieure (L_CB) qui est inférieure à la taille du bloc de données d'entrée (IDB),
dans lequel le procédé comprend les étapes suivantes exécutées par le dispositif de segmentation :

- la détermination de la longueur du bloc de données d'entrée (IDB) avant le codage de l'une quelconque de ses données avec ledit codeur de blocs (TE),

- le calcul de la taille d'une pluralité de segments (S₁ ... S_N), dans lequel aucun segment n'est plus grand que ladite limite supérieure (L_CB),

- la division du bloc de données d'entrée (IDB) en la pluralité de segments (S₁ ... S_N), et

- l'application de chaque segment (S₁ ... S_N) audit codeur de blocs (TE),

- dans lequel le calcul de la taille utilise les entrées suivantes :

R_DATA = débit de données de l'utilisateur en bits par seconde,

T_DELAY = longueur du bloc de données de l'utilisateur codant en secondes,

N_EXTRA = bits de données supplémentaires à annexer au bloc de données de l'utilisateur avant le codage

N_TAIL = nombre de bits d'extrémité à annexer aux blocs de codage

- et dans lequel le calcul de la taille produit les sorties suivantes :

N_S = nombre de segments,

N_TB = nombre de bits dans chaque segment,

N_FILL = nombre de bits de remplissage destinés à remplir le bloc de données d'entrée ou le dernier segment,

- et dans lequel les calculs suivants sont exécutés :

N_S = arrondi_vers_le_haut ((R_DATA * T_DELAY + N_EXTRA) / (L_CB - N_TAIL)),

N_TB = arrondi_vers_le_haut ((R_DATA * T_DELAY + N_EXTRA) / N_S) + N_TAIL,

N_FILL = (N_S - N_REM) si N_REM # 0, sinon N_FILL = 0,
dans lequel

N_REM = reste de (R_DATA * T_DELAY + N_EXTRA) / N_S.

2. Un dispositif de segmentation destiné à segmenter un bloc de données d'entrée (IDB) pour un traitement avec un codeur de blocs (TE), ledit codeur de blocs étant capable de traiter des blocs de codage consécutifs (CB) dont la taille possède une limite supérieure (L_CB) qui est inférieure à la taille du bloc de données d'entrée (IDB), dans lequel le dispositif de segmentation est agencé de façon à :

- déterminer la longueur du bloc de données d'entrée (IDB) avant l'application de l'une quelconque de ses données audit codeur de blocs (TE),

- calculer la taille d'une pluralité de segments (S₁ ... S_N), dans lequel aucun segment n'est plus grand que ladite limite supérieure (L_CB),

- diviser le bloc de données d'entrée (IDB) en la pluralité de segments (S₁ ... S_N), et

- appliquer chaque segment (S₁ ... S_N) audit codeur de blocs (TE),

- dans lequel le calcul de la taille utilise les entrées suivantes :

R_DATA = débit de données de l'utilisateur en bits par seconde,

T_DELAY =longueur du bloc de données de l'utilisateur codant en secondes,

N_EXTRA = bits de données supplémentaires à annexer au bloc de données de l'utilisateur avant le codage,

N_TAIL = nombre de bits d'extrémité à annexer aux blocs de codage

- et dans lequel le calcul de la taille produit les sorties suivantes :

N_S = nombre de segments,

N_TB = nombre de bits dans chaque segment,

N_FILL = nombre de bits de remplissage destinés à remplir le bloc de données d'entrée ou le dernière segment,

- et dans lequel les calculs suivants sont exécutés :

N_S = arrondi_vers_le_haut ((R_DATA * T_DELAY + N_EXTRA) / (L_CB - N_TAIL)),

N_TB = arrondi_vers_le_haut ((R_DATA * T_DELAY + N_EXTRA) / N_S) + N_TAIL,

N_FILL = (N_S - N_REM) si N_REM ≠ 0, sinon N_FILL = 0,
dans lequel

N_REM = reste de (R_DATA * T_DELAY + N_EXTRA) / N_S.

3. Un codeur de blocs (TE), dans lequel le codeur de blocs comprend un dispositif de segmentation selon la revendication 2.

Drawing