El pasaje de la noción de grado cero al campo audiovisual

To minimise memory use the frequency de-interleaver may be implemented with a single memory comprising N_max locations. N_max is the maximum number of data cells in an OFDM symbol of the given FFT size. It is envisaged that practical implementations of DVB-T2 receivers should support all the FFT sizes included in [i.1]. In such

implementations, N_max would be the memory capacity necessary to implement odd-even interleaving for 32 K. Thus,

N_max = 27 404 since this is the maximum number of data cells (C_data) in 32 K mode with PP8 Scattered Pilot pattern, extended carrier mode and no tone reservation (see table 42 of [i.1]). The frequency de-interleaver for all modes can thus be implemented with one memory having C_max locations (for 32 K) or 2C_max locations (for all other modes) where

C_max=max(C_data) for the given mode. For most system configurations, not all of these locations would be needed. NOTE: This is the reason why there are always an even number of symbols in 32 K. Otherwise the last symbol of

one T2-frame and the P2 symbol of the next T2-frame could both be even, and odd-even interleaving using a single memory would not be possible.

The receiver buffer model (clause 8.8.1) assumes that the L1 and frequency de-interleavers are combined, and that the combined interleaver can be used for to provide a certain amount of buffering. Since this is included in the model that the T2-gateway will used to manage the receiver's buffers, it is recommended that the same implementation be used in receivers.

The function of the combined de-interleaver is to accept data cells in carrier order, and to output first the L1 cells followed by the data cells in order of cell address. It should also be able to retain cells of the P2 symbols to allow time for the L1 signalling to be decoded. First, the L1-post cells need to be kept in the de-interleaver until the L1-pre has been decoded, so that the receiver knows how many L1-post blocks and how many cells per L1-post block there are. Second, the PLP cells need to be kept while the L1-post is decoded, so that the receiver knows which data cells belong to the current PLP or PLPs. Finally the remaining data cells in the P2 symbols should be output at a slightly higher rate than normal (Rs), in order to finish reading them before the next symbol begins.

In the case of 32 K or 16 K, there is only one P2 symbol, so the ordinary frequency de-interleaver will naturally output the L1 cells first followed by the PLP cells. In other modes, the "zig-zag" mapping needs to be undone.

10.4.1.1

Implementation of L1/Frequency de-interleaver 32 K

For odd-even interleaving as used in 32 K, the de-interleaver should read data cells from even symbols (symbol number of form 2n) into its memory in a sequential order. For odd symbols (symbol number of form 2n + 1) the data cells are read into memory in a permuted order, the permuted order addresses H(p) being provided by the relevant

pseudo-random address generator from clause 8.5 of [i.1]. As only one memory is used in the de-interleaver and in order to avoid losing data cells, one cell of the previous symbol should be read out from the memory location to which the cell of the current symbol is to be written. It therefore follows that the sequence of write addresses for symbol number 2n + 1 should match the sequence of read addresses for symbol number 2n otherwise some data cells of symbol 2n will be overwritten. Thus, if all symbols contained the same number C_max = C_data of data cells, then starting from symbol 2n at the input of the de-interleaver, the de-interleaver would follow the following steps:

1) p = 0;

2) Read cell p of output de-interleaved symbol 2n - 1 from location p of the memory; 3) Write cell p of incoming interleaved symbol 2n into location p of the memory; 4) Increment p;

5) if (p < C_max) go to 2.

Then with symbol 2n + 1 at the input of the de-interleaver: 6) p = 0;

8) Read cell p of output de-interleaved symbol 2n from location H(p) of the memory; 9) Write cell p of incoming interleaved symbol 2n + 1 into location H(p) of the memory; 10) Increment p;

11) if (p < C_max) goto 7.

Note that in 32 K, there is always an even number of symbols in a T2-frame, so the odd-even sequence continues, even across frame boundaries. In other FFT sizes there can be an odd number of symbols but this is not a problem since there is always at least two-symbols' worth of memory available.

Things are more complicated, however, because the T2-frame in DVB-T2 is composed of different types of symbol with correspondingly different number of data cells for each type of symbol. Thus for a given system configuration (FFT size, Scattered Pilot pattern, bandwidth extension and tone-reservation status), a P2 symbol carries fewer data cells than a data symbol which in turn carries more data cells than the frame-closing symbol. Imagine that the de-interleaver is about to process symbol 2n + 1 (a data symbol) for which the preceding symbol 2n was a P2 symbol. Then since data symbols have more data cells than P2 symbols, it follows that the number of generated addresses in the loop 7 to 11 above would exceed the number of data cells carried by the P2 symbol. Therefore, the pseudo-random address generator would produce some addresses that are valid for writing cells of symbol 2n + 1 into memory but not valid for reading cells of symbol 2n. The case in which symbol 2n has more data cells than symbol 2n + 1 also occurs when going from a data symbol to a frame-closing symbol. For a given system configuration therefore

C_max = max(C_data, C_P2, C_FC)= C_data. The loops above should be changed as follows where the function DataCells(l) returns the number of data cells in symbol l and HoldBuffer is a small amount of storage with write address wptr and read address rptr:

1) p = 0; wptr = rptr = 0;

2) rdEnable = (p < DataCells(2n - 1)); 3) wrEnable = (p < DataCells(2n));

4) if (rdEnable) Read cell p of output de-interleaved symbol 2n - 1 from location p of the memory; 5) Store cell p of incoming interleaved symbol 2n into location wptr of HoldBuffer and increment wptr; 6) If (wrEnable):

a) Write cell rptr of HoldBuffer into location p of the memory and increment rptr.

b) If (rptr == wptr) then reset rptr = wptr = 0. 7) Increment p;

8) if (p < C_max) goto 2;

Then with symbol 2n + 1 at the input of the de-interleaver: 9) p = 0; wptr = rptr = 0;

10) Generate address H(p);

11) rdEnable = (H(p) < DataCells(2n - 1)); 12) wrEnable = (H(p) < DataCells(2n));

13) if (rdEnable) Read cell p of output de-interleaved symbol 2n from location H(p) of the memory;

15) If (wrEnable):

a) Write cell rptr of HoldBuffer into location H(p) of the memory and increment rptr.

b) If (rptr == wptr) then reset rptr = wptr = 0. 16) Increment p;

17) if (p < C_max) goto 10.

10.4.1.2

Implementation of the basic frequency de-interleaver in 1 K-16 K

Similarly for modes other than 32 K that use odd-only interleaving, with symbol 2n at its input the de-interleaver steps for the basic frequency de-interleaver are as follows. Modifications to implement the combined L1/Frequency

de-interleaver are described in clause 10.4.1.3. 1) p = 0; wptr = rptr = 0;

2) Generate address H₀(p); 3) Generate address H₁(p);

4) rdEnable = (H₁(p) < DataCells(2n - 1)); 5) wrEnable = (H₀(p) < DataCells(2n));

6) if (rdEnable) Read cell p of output de-interleaved symbol 2n - 1 from location C_max + H₁(p) of the memory; 7) Store cell p of incoming interleaved symbol 2n into location wptr of HoldBuffer and increment wptr; 8) If (wrEnable):

a) Write cell rptr of HoldBuffer into location H₀(p) of the memory and increment rptr. b) If (rptr == wptr) then reset rptr = wptr = 0.

9) Increment p; 10) if (p < C_max) goto 2.

Then with symbol 2n+1 at the input of the de-interleaver: 11) p = 0; wptr = rptr = 0;

12) Generate address H₀(p); 13) Generate address H₁(p);

14) rdEnable = (H₀(p) < DataCells(2n)); 15) wrEnable = (H₁(p) < DataCells(2n + 1));

16) if (rdEnable) Read cell p of output de-interleaved symbol 2n from location H₀(p) of the memory; 17) Store cell p of incoming interleaved symbol 2n + 1 into location wptr of HoldBuffer and increment wptr;

18) If (wrEnable):

a) Write cell rptr of HoldBuffer into location C_max + H₁(p) of the memory and increment rptr. b) If (rptr == wptr) then reset rptr = wptr = 0.

19) Increment p;

20) if (p < C_max) goto 12.

The required width for each memory location depends on the resolution with which each cell is represented after channel equalisation. Each de-interleaver memory cell would hold at least: the complex cell information and the channel state information for the cell. If rotated constellations were used, the complex channel coefficient might also be included.

10.4.1.3

Implementation of the L1/ Frequency De-interleaver in 1 K-16 K

Figure 91 shows how the combined de-interleaver can be implemented in memory. The figure is for 8 K, with two P2 symbols, but the principle can easily be extended to other modes. The red and green cells are L1-pre- and post- cells respectively, and the blue cells are data cells.

Each row of the memory is used to store one symbol. In all modes except 32 K, the size of the de-interleaver memory will always be twice the number of P2 symbols. Whilst the P2 symbols are being received, they are stored in the memory (a and b in figure 91). Because of the way the interleaving is defined, the de-interleaver should write in permuted order, as described in clause 10.4.1.2. Once all the P2 symbols have been received, they can start to be read out; meanwhile the following data symbols are written to the other half of the memory (c). The effect of writing in permuted order is that the cells are now in de-interleaved order in the memory. The figure (c) shows how the L1-pre cells can be read out in order, followed by the L1-post, followed by the data cells. Once the P2 symbols have been read out, the rows that have been freed up can be used for the next data symbols (d).

The de-interleaver as shown will always have approximately NP2 symbols' delay.