Patent Publication Number: US-7725810-B2

Title: Decoding of multiple data streams encoded using a block coding algorithm

Description:
TECHNICAL FIELD 
   The present disclosure generally concerns the decoding of data coded using a block coding algorithm. 
   It has applications particularly but not exclusively in devices for receiving signals transmitted by satellite, for example using the satellite digital video broadcasting standard DVB-S2, which stipulates the use of a low density parity check (“LDPC”) code to protect the data transmission. 
   BACKGROUND INFORMATION 
   LDPC codes are a class of error correction codes invented in 1960 by Robert Gallager of MIT (“Massachusetts Institute of Technology”), constituting an alternative to the Viterbi codes as well as to the more recent turbo codes. LDPC codes are block codes which allow approaching the Shannon Limit. The first commercial standard stipulating the use of an LDPC code is the DVB-S2 standard, which is the second-generation ETSI (“European Telecommunication Standardization Institute”) standard for satellite digital video broadcasting. LDPC coding is included in it for channel coding, to protect the sent data from noise affecting the transmission channel. 
   With reference to  FIG. 1 , a generic transmission subsystem contains, on the side of the sender  10 , a data source  11  (denoted DAT_SRC in the figure), followed by a source encoder  12  (denoted SCR_ENC in the figure), a channel encoder  13  (denoted CH_ENC in the figure), and a modulator  14  (denoted MOD in the figure). The source encoder  12  compresses the data (for example using a standard such as MPEG, H264, etc.) so as to reduce the bit rate of the data to be transmitted. The channel encoder adds redundancy (for example by using an LDPC code) to enable the receiver  30  to correct potential errors due to the noise introduced into the transmission channel  20 . The modulator  14  adapts the signal to the transmission channel (for example, satellite transmission channel, radio transmission channel, etc.). On the receiver side  30 , a demodulator  34  (denoted DEMOD in the figure), followed by a channel decoder  33  (denoted CH_DEC in the figure), and a source decoder  32  (denoted SRC_DEC in the figure), perform operations dual to those performed by the modulator  14 , the encoder  13 , and the encoder  12 , respectively. The demodulated and decoded data are then restored to the entity that uses the data  31  (denoted DAT_U in the figure). 
   When the channel coding uses a block coding algorithm, as is the case for LDPC codes, the channel decoder comprises an input memory, or channel memory, for storing the data to be decoded. In the known decoders, this memory may comprise a first single port storage element configured for storing a block of bits corresponding to a previously received code word which is currently being decoded, and a second single port storage element configured for storing another block of bits corresponding to a code word currently being received. The processes of receiving and decoding may thus be simultaneous. To avoid the input memory of the decoder becoming full, the block decoding time must be less than the block receiving time. In order to have the highest possible bit rate, the block receiving time must be as low as possible. Therefore, as a general rule, the block decoding time is close to the block receiving time while being less than this receiving time. 
   BRIEF SUMMARY 
   One embodiment of the present invention particularly applies to digital satellite television receivers which provide simultaneous demodulation and decoding of at least two different data streams. In systems of this type, for example, a first data stream may correspond to a program watched by a user, while a second data stream may correspond to a program being saved at the same time to a hard drive or similar storage. Other applications can of course result in simultaneous demodulation and decoding of at least two different data streams coded using a block coding algorithm, and are therefore also concerned by embodiments of the present invention. Although block coding algorithms are generally used for channel coding, embodiments of the invention are not limited to this use, and in fact applies to any type of block coding. 
   In receivers of the abovementioned type, currently two front end chips are used, respectively ensuring the demodulation and decoding of each of the two streams. This solution implies a high cost, particularly the cost of the two chips and the cost of their integration into the system. 
   This is why an embodiment of the invention enables decoding at least two data streams coded with a block coding algorithm, such as an LDPC code, using a single decoder. 
   To this end, according to a first aspect, the invention proposes a block decoder for this purpose, comprising:
         a first input and at least a second input for respectively receiving a first data stream for decoding and a second data stream for decoding which is distinct from said first data stream,   an input memory with storage elements configured for storing blocks of data from the first data stream and blocks of data from the second data stream,   a block decoding unit configured to process from the input memory the blocks of data from the first and second data streams, and   a control unit for multiplexing the blocks of data from the first data stream and the blocks of data from the second data stream as input to the block decoding unit, which is achieved by saving and reading them in the storage elements of the input memory.       

   One embodiment of the invention utilizes the possibility of designing an LDPC decoding unit which is at least twice as fast as is required by the end application. In fact, it is currently known how to design LDPC decoders meeting the standard which can process data with an input bit rate of several hundred megabits/second (Mbps). One may refer to the article “A 135 Mbps DVB-S2 Compliant Codec based on 64800-bit LDPC and BHC Codes”, P. Urard et al., Proc. IEEE ISSCC 2005, pp. 446-447, February 2005, San Francisco, Calif., concerning this. 
   Thanks to embodiments of the invention, a single system may integrate two demodulators and one LDPC decoder, to enable the demodulation and decoding of two distinct data streams. A second aspect of the invention relates to a system comprising:
         a first demodulator for generating a first data stream to be decoded, and a second demodulator for generating a second data stream to be decoded, and   a block decoder according to the first aspect of the invention for decoding the data from the first and second data streams.       

   Such a system may be implemented in the form of a System on Chip (SoC), meaning it is integrated in a single integrated circuit package. 
   The increase in the silicon surface area occupied by an integrated circuit having two demodulators and one LDPC decoder in comparison to an integrated circuit having one demodulator and one LDPC decoder is slight, for the following reasons. Firstly, the silicon surface area occupied by a demodulator is 5 to 15 times smaller than that occupied by an LDPC decoder. Secondly, the increase in the silicon surface area occupied by an LDPC decoder twice as fast as a standard LDPC decoder is not excessive, given that the major part of the silicon surface area occupied by the LDPC decoder corresponds to storage elements whose capacity does not depend on the processing speed for a given decoding algorithm. 
   A third aspect of the invention relates to a receiver for satellite transmissions comprising a system according to the second aspect. 
   Finally, a fourth aspect of the invention concerns a method of block decoding comprising:
         the receiving of a first data stream to be decoded and at least a second data stream to be decoded which is distinct from said first stream,   the storage in the storage elements of an input memory of a block decoder, of at least one block of data from the first data stream and at least one block of data from the second data stream,   the block decoding from the input memory, by the block decoder, of blocks of data from the first and second data streams, and,   the multiplexing of blocks of data from the first stream and blocks of data from the second stream as input to the block decoding unit, which is achieved by saving and reading them in the storage elements of the input memory.       

   
     BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
     Other features of one or more embodiments of the invention will become apparent in reading the following description. This is purely illustrative and non-limiting and should be read with reference to the attached drawings, in which: 
       FIG. 1 , already described, is a diagram illustrating a generic data transmission subsystem, 
       FIG. 2  shows an example of a parity check matrix and illustrates its application in an LDPC frame according to an embodiment, 
       FIG. 3  illustrates the example calculations for updating check nodes and bit nodes performed using the parity check matrix of  FIG. 2  according to an embodiment, 
       FIG. 4  is a diagram illustrating the sharing of a decoder in a system according to embodiments of the invention, for the processing of two data streams to be decoded, 
       FIG. 5  is a diagram of the architecture of an LDPC decoder according to embodiments of the invention, 
       FIG. 6  is a step diagram illustrating a first example of an algorithm for managing writes to the buffers of the input memory of an LDPC decoder according to embodiments of the invention, 
       FIG. 7  is a step diagram illustrating an example of an algorithm for managing reads from the buffers of the input memory of a decoder according to some embodiments, in which the write algorithm conforms with the step diagram in  FIG. 6  or the step diagrams of  FIGS. 8 and 9 , 
       FIGS. 8 and 9  are step diagrams illustrating a second example of an algorithm for managing writes to the buffers of the input memory of a decoder according to other embodiments of the invention, and 
       FIG. 10  is a diagram illustrating the operation of a device according to an embodiment of the invention. 
   

   DETAILED DESCRIPTION 
   In the following description, numerous specific details are given to provide a thorough understanding of embodiments. One skilled in the relevant art will recognize, however, that the invention can be practiced without one or more of the specific details, or with other methods, components, materials, etc. In other instances, well-known structures, materials, or operations are not shown or described in detail to avoid obscuring aspects of the invention. 
   Reference throughout this specification to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment. Thus, the appearances of the phrases “in one embodiment” or “in an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. 
   Embodiments of the invention are given below for the case of data coded with an LDPC code. The LDPC codes are block codes. On the transmitter side, the LDPC encoder processes blocks of K information bits, and outputs code words of N bits, also called LDPC frames, where N&gt;K. In other words, it adds N−K redundancy bits which enable the correction of transmission errors on the receiver side. These N−K bits are called parity bits. The code rate is defined as the ratio r=K/N. The smaller the r, the higher the redundancy, and therefore the higher the protection against noise in the transmission channel. 
   The N−K bits added to each block of K information bits are calculated using an H matrix, called the parity check matrix. This H matrix has N−K rows and N columns. It contains “0” and “1” values, with the latter in low proportions, which is why codes based on such a parity matrix are called low density parity check codes. 
   With reference to  FIG. 2 , an N-bit LDPC frame, in which the K low order bits correspond to the information bits and the N−K high order bits correspond to the parity bits, is the code word C delivered by an LDPC encoder which satisfies the relation:
 
 H×C   t =0
 
   The check node degree for a row in the H matrix is the number of “1” values in the row, and the bit node degree for a column in the H matrix is the number of “1” values in the column. There exist two types of LDPC code: the regular codes and the irregular codes. The H matrix for a regular code has a constant number of “1” values per row and per column, meaning that the check node degrees and bit node degrees are constant. Conversely, the H matrix for an irregular code does not have constant check node degrees and/or bit node degrees, and is therefore more random in character. The best performance is obtained with irregular codes, but the decoding may then be more difficult. The DVB-S2 standard recommends the use of an H matrix which has constant check node degrees, between 4 and 30 (abbreviated as matrix check node degree), and bit node degrees which may assume three values between 2 and 13. 
   On the receiver side, the LDPC decoder corrects the erroneous bits by using the relations between the bits in the LDPC frames received through the transmission channel, corresponding to a word C′. These relations are given by the parity check matrix H, which is of course known to the decoder. 
   More particularly, the LDPC decoder processes log-likelihood ratios (LLR). On the receiver side, there is an LLR for each of the N bits of an LDPC frame which was sent from the transmitter. For a transmitted bit d which has a corresponding signal x received by the LDPC decoder after noise is added to the transmission channel, the LLR ratio for the bit d in relation to the signal x is defined as: 
             LLR   ⁡     (   x   )       =       LLR   ⁡     (     d   /   x     )       =     ln   ⁢       P   ⁡     (     d   =     0   /   x       )         P   ⁡     (     d   =     1   /   x       )                   
where P(d=0/x) is the probability that the transmitted bit d is equal to 0 as a function of the value x received, and P(d=1/x) is the probability that the transmitted bit d is equal to 1 as a function of the value x received. Each LLR is coded in m bits.
 
   The LDPC decoder uses internal metrics, equal in number to the number of “1” values in the H matrix. These metrics are each coded in t bits. The decoder updates them using an iterative algorithm. 
   With reference to  FIG. 3 , each iteration comprises update steps performed by row, including determining for each row the first new values for the internal metrics of the row as a function of the other internal metrics of the row (“check node update”), then update steps performed by column, including determining for each column the second new values for internal metrics of the column as a function of the other internal metrics of the column and the LLR corresponding to this column (“bit-node update”). For decoding a received LDPC frame, in order to retrieve a block of N data sent, the decoder performs several iterations. The decoded bits, called hard decision bits, are then obtained by adding the internal metrics by column with the LLRs for the C′ word received, and taking the sign of the result. 
   With reference to  FIG. 4 , a system  50  according to the embodiments of the invention comprises two demodulators  54   a  and  54   b , and a decoder  52 , for example a channel decoder. For example, this is a system for receiving signals sent using the DVB-S2 standard, the  54   a ,  54   b  demodulators are for example 8-PSK demodulators, and the decoder  52  is for example an LDPC decoder. Even so, a person skilled in the art will appreciate that one embodiment of the invention applies to any type of block decoder. 
   The demodulator  54   a  generates a first stream S 1  of data to be decoded. The demodulator  54   b  generates a second stream S 2  of demodulated data to be decoded. These data are organized into blocks in relation to the LDPC frames sent from the transmitter. 
   The decoder  52  may provide a multiplexing function, having a first input for receiving the stream S 1  and a second input for receiving the stream S 2 . For example, the decoder may be configured to alternate between processing a block of data from stream S 1  corresponding to a code word to be decoded, then a block of data from stream S 2  corresponding to another code word to be decoded. Other forms of time multiplexing are of course possible. 
   With reference to  FIG. 5 , an example architecture for the LDPC decoder  52  comprises, according to some embodiments, an input memory or a channel memory  41  (denoted CH_MEM in the figure) which can store blocks of data to be decoded corresponding to four LDPC frames sent from the transmitter side. These data in fact correspond to 4×N LLRs. 
   More particularly, the memory  41  comprises at least four single port storage elements  41   —   i , where i assumes the values of whole numbers between 1 and 4, instead of two such storage elements for the input memory of a decoder in the prior art. Each of these storage elements is configured to store a block of data to be decoded, with such a block here indicating the unit of data processed by the decoding algorithm. In other words, each storage element  41   —   i  is configured to store a block of N×m bits corresponding to the N LLRs associated with a word previously received and currently being decoded, or a block of N×m bits corresponding to the N LLRs associated with a code word currently being received. 
   For example, the storage elements  41   —   i  are single port RAM (or SPRAM), each forming a buffer. 
   Under the control of a control unit  46 , blocks of data from the stream S 1  and blocks of data from the stream S 2  are multiplexed via saving and reading them in the storage elements  41 - i  of the storage  41 . 
   In one embodiment (hereinafter the first embodiment), wherein the maximum bit rate for each of the streams S 1  and S 2  is always less than M/2 where M designates the maximum input bit rate for the decoder  52 , the memory  41  comprises a pair of storage elements (for example the elements  41 _ 1  and  41 _ 2 ) which is used to store the data from the stream S 1 , and another pair of storage elements (for example the elements  41 _ 3  and  41 _ 4 ) which is used to store the data to be decoded from the stream S 2 . In other words, in this first embodiment, the data from each of the streams S 1  and S 2  pass only through the storage elements of one of the pairs of elements  41 _ 1 ,  41 _ 2 , and  41 _ 3 ,  41 _ 4  respectively. 
   In another embodiment (hereinafter the second embodiment), wherein the maximum respective bit rates for each of the streams S 1  and S 2  may be greater than M/2 but their sum is always less than M, the registers  41   —   i  where i assumes the values of whole numbers between 1 and 4, are used by order of priority for storing data from streams S 1  and S 2 . In other words, in this embodiment, the data to be decoded from streams S 1  and S 2  may pass through any of the four storage elements  41   —   i . Unlike the first embodiment, this second embodiment allows decoding data streams which have a higher bit rate, while using the same number of storage elements. However, the management of the storage elements is more complex, as will now be shown. 
   Examples of storage element management algorithms, both for reading and writing, will be presented further on. These algorithms are implemented in the control unit  46 . Said unit  46  is represented here as a separate functional entity, but it may be implemented as hardware and/or software as a part of another decoder element, for example the memory  41  itself, or of a decoding unit which will now be described. 
   In order to accelerate the calculations related to decoding, the decoding unit comprises a processor bank  42 , comprising a number P of parallel processors (denoted Proc 1  to ProcP in the figure) which perform in parallel the calculations for the check nodes and bit nodes. The number P is called the parallelism index. The processor bank  42  has read access to the input memory  41  via a bus of m×P wires, controlled by the unit  46 . 
   During execution of the iterative process, the processors deliver updated values of internal metrics, each coded in t bits. The internal metrics are stored in a metric memory  43  (denoted MET_MEM in the figure), which has a capacity equal to t times the number of metrics (meaning t times the number of “1” values in the H matrix). The internal metrics stored in the memory  43  are delivered to the processor bank  42  via a mixer with P channels, such as a barrel shifter  44  (denoted BS in the figure) in the case of the DVB-S2 standard. The memory  43  is read and write accessible via respective buses of t×P wires. 
   After the last iteration, the processor bank  42  also delivers hard decision bits, which assume the values “1” or “0” depending on the sign of the sum of the columns of the H matrix and the LLRs for the C′ word of the corresponding rank. These hard decision bits are stored temporarily in an output buffer, or hard decision memory  45  (denoted HD_MEM in the figure). The capacity of the memory  45  is equal to N, the size of an LDPC frame. The processor bank  42  can write to the memory  45  via a bus of P wires. 
   The elements  42 ,  43 ,  44  and  45  form the decoding unit of the decoder  52 , here an LDPC decoding unit which is configured for processing the data stored in the input memory  41 . The blocks of data from the stream S 1  and from the stream S 2  are multiplexed as input in the form of a stream S 3  of data to be decoded, provided as input to this decoding unit. 
   In an embodiment, K=16200, N=64800, P=360, m=6, and t=6. 
   In the text below, the term “set” is used in reference to a logical value (called a flag), to signify that “the flag is set to the logical value of 1.” Similarly, the term “reset” is used to signify that “the flag is (re)set to the logical value of 0.” 
   In the first embodiment discussed above, at least two flags are associated with each the storage elements  41   —   i , where i is between 1 and 4. A first flag is denoted “used_i”, where i may assume the values of whole numbers between 1 and 4 for each of the respective storage elements  41   —   i . This “used_i” flag is set (i.e., used_i=1) when the associated storage element  41   —   i  is being write accessed, meaning data to be decoded are currently being written to it, or when it is completely full of data to be decoded which have not yet all been decoded. A second flag denoted “full_i”, where i may assume whole numbers between 1 to 4 for each of the respective elements  41   —   i , is set when the associated storage element is completely full of data to be decoded which have not yet all been decoded. 
   With reference to  FIG. 6 , an algorithm for writing to the input memory  41  according to the first embodiment of the invention is as follows. 
   In a step  71 , it is monitored whether data to be decoded corresponding to a new LDPC frame, which may belong to stream S 2  or to stream S 2 , has been received. 
   Next, in a step  72 , it is identified whether the data received correspond to a frame from the stream S 1  or a frame from the stream S 2 . This identification may be done directly by testing on which of the two buses a new frame has been received as input to the memory  41 . 
   First we will consider the case where the new frame received belongs to the stream S 1  (the steps in the left part of the figure). In one step  731 , it is determined whether the storage element  41 _ 1  is write accessible, meaning it is not in the process of having data to be decoded written to it and is not already full of data to be decoded which have not yet all been decoded. For this purpose, the used — 1 flag is tested. 
   If it is not set (case where used — 1=0), then this means the storage element  41 _ 1  is write accessible. As a result, in a step  741 , the bits of the LLRs associated with the newly received frame are stored in element  41 _ 1  and the used — 1 flag is set. 
   If, on the other hand, the used — 1 flag is set (case where used — 1=1) this means that
         (i) the element  41 _ 1  is full of data to be decoded which have not yet all been decoded, in which case the full — 1 flag is in principle already set (full — 1=1), or that   (ii) this element  41 _ 1  was previously in the process of being written to with data for decoding associated with a frame which is now completely received, in which case, the full — 1 flag was not set but should be. This is why, in a step  742 , the full — 1 flag is set.       

   As a result, in the case (i) above the full — 1 flag is left at 1, and in the case (ii) above, it is changed from 0 to 1. 
   After the step  742 , it is determined whether the storage element  41 _ 2  is write accessible, meaning it is not in the process of having data to be decoded written to it and is not already full of data to be decoded which have not yet all been decoded. For this purpose, the used — 2 flag is tested. If this flag is not set (case where used — 2=0), this indicates that the element  41 _ 2  is write accessible. In a step  751 , the data corresponding to the newly received frame are then saved in element  41 _ 2  and the used — 2 flag is then set. Otherwise (case where used — 2=1) this indicates that neither of the storage elements  41 _ 1  and  41 _ 2  are available for storing the data corresponding to the newly received frame. In principle, this should not happen if the bit rate constraints on the streams S 1  and S 2  are met. This is why the algorithm is set up to generate, in a step  752 , an error which is then handled in an appropriate manner, for example by skipping a frame. 
   In a step  732 , it is also determined whether the element  41 _ 2  is available. To do this, the used — 2 flag is tested. If this flag is set, this indicates that the element  41 _ 2  is already in the process of being written to with data to be decoded, or that it is already full of data to be decoded which have not yet all been decoded. As was the case in the step  742  for the register  41 _ 1 , the full — 2 flag is then set in a step  743 . Otherwise, nothing is done. 
   A result of the above algorithm is that the data to be decoded which are associated with a newly received frame are stored in the storage element  41 _ 1 . In an embodiment, only if this element is not available are the data stored in the element  41 _ 2 . As has been said, the case where neither of the two storage elements  41 _ 1  and  41 _ 2  is available should in principle not occur if the bit rate for each of the streams S 1  and S 2  is less than M/2, where M is the maximum input bit rate for the decoder  52 . 
   The right part of  FIG. 6  illustrates steps equivalent to those just described above, but these refer to the handling of the used_i and full_i flags associated with the storage elements  41 _ 3  and  41 _ 4  (with i=3 and i=4), in the case where the newly received frame belongs to the stream S 2 . These steps are completely symmetrical with those described above for the frames from the stream S 1 , and therefore do not need to be described again here. 
   We will now describe the steps in an algorithm for reading from the input memory  41  according to the first embodiment, with reference to  FIG. 7 . For implementing this algorithm, the decoder maintains a “decoder_busy” flag, which is set when the decoder is busy, meaning in the process of decoding data, and a “buffer_proc” flag, which assumes the value of a whole number between 1 and 4 depending on whether the data stored in the respective elements  41 _ 1 ,  41 _ 2 ,  41 _ 3  or  41 _ 4  is in the process of being decoded. The decoder_busy and buffer_proc flags are initialized to 0. 
   In a step  80 , the case where the decoder is busy is distinguished from the case where the decoder is not busy. The decoder_busy flag can be tested for this purpose. 
   If the decoder_busy flag is not set (decoder_busy=0), meaning the decoder is not busy, the question is whether one of the storage elements  41   —   i  is full of data to be decoded which have not yet all been decoded. For this purpose, the full_i flags, where i is between 1 and 4, are successively tested in the respective steps  81  to  84 . In fact, each full_i flag where i is between 2 and 4 is only tested if none of the previously tested full_i flags were set. If it is determined in any of the steps  81  to  84  that the corresponding full_i flag is set, the decoder_busy flag is set and the buffer_proc flag is assigned the corresponding i value between 1 and 4. Then the process proceeds to step  80  without testing the other full_i flags. 
   If it is determined in step  80  that the decoder_busy flag is set (decoder_busy=1), meaning the decoder is busy, it is decided in a step  85  whether the iterative process for decoding data has reached its last cycle. If this is the case, then in a step  851  the full_i and used_i flags are reinitialized, where i is the whole number corresponding to the value (assumed not to be null) of the buffer_proc flag, and then the algorithm returns to step  80 . Otherwise, it returns directly to step  80 . 
   The example algorithm described above gives priority to decoding data stored in the storage elements  41 _ 1 ,  41 _ 2 ,  41 _ 3  and  41 _ 4  in that order. Of course, it is possible to do differently. A person skilled in the art will know how to adapt the algorithm in light of the above. 
   We will now describe an algorithm for writing to the input memory  41  according to the second embodiment, as shown in  FIGS. 8 and 9 . In this second embodiment, the system maintains an additional flag, denoted “mod_i” where i assumes the value of a whole number between 1 and 4, associated with each of the respective storage elements  41 _ 1 ,  41 _ 2 ,  41 _ 3  or  41 _ 4 . This mod_i flag assumes the value of 1 or the value of 2 depending on whether the data to be decoded which are stored in the associated storage element  41   —   i  belong to the stream S 1  or the stream S 2  respectively. 
   With reference to  FIG. 8 , which illustrates the management of the used_i and mod_i flags, the algorithm first comprises the steps  71  and  72  previously described in reference to  FIG. 6  concerning the first embodiment. These steps are not described again here. 
   To continue, we will consider first the case where the newly received frame belongs to the stream S 1  (the steps in the left part of the figure). In steps  911 ,  921 ,  931  and  941 , it is determined whether the respective storage elements  41 _ 1 ,  41 _ 2 ,  41 _ 3  and  41 _ 4  are write accessible, meaning not in the process of being written to with data to be decoded and not already full of data to be decoded which have not yet all been decoded. 
   For this purpose, the used_i flag is tested, where i assumes the values of whole numbers between 1 to 4. Each used_i flag, where i is between 2 and 4, is only tested if each of the previously tested used_i flags is set. If it is determined in any of the steps  911 ,  921 ,  931  or  941  that the corresponding used_i flag is not set (case where used_i=0), this indicates that the associated storage element is write accessible. As a result, the bits of the LLRs associated with the newly received frame are then stored in the corresponding element  41   —   i , and the used_i flag is set and the mod_i flag is assigned the value of 1 in the respective step  912 ,  922 ,  932  or  942 . Then the algorithm passes to step  71 , without testing the other used_i flags. 
   If it is determined in step  941  that the last storage element  41 _ 4  is not available (used — 4=1), the algorithm passes to step  71  without storing the LLR bits associated with the newly received frame. In other words, a frame is skipped, but in principle this should not happen if the constraints are met for the maximum bit rate of the streams S 1  and S 2  related to this embodiment, meaning the sum of the bit rates for each of the streams S 1  and S 2  is less than M, where M is the maximum input bit rate for the decoder  52 . 
   In one variation, an error routine may be executed, as is the case in the first embodiment (step  752  in  FIG. 6 ). 
   In the right part of  FIG. 8 , steps equivalent to those just described above are illustrated, but these refer to the handling of the used_i and mod_i flags when the newly received frame belongs to the stream S 2 . These steps are symmetrical with those described above for the frames from the stream S 1 , and therefore do not need to be described again here. One will note merely that, when the bits of the LLRs associated with the newly received frame are stored in element  41   —   i  and the used_i flag is set, here the mod_i flag is assigned the value of 2 (instead of 1 as is the case when the new frame belongs to the stream S 1 ). 
   With reference to  FIG. 9 , which illustrates the algorithm for handling the full_i flag, one will note that this algorithm also comprises the first steps  71  and  72  which have already been described in reference to  FIG. 6  concerning the first embodiment of the invention. 
   As before, we will first consider the case where the newly received frame belongs to the stream S 1  (the steps in the left part of the figure). In the steps  111 ,  121 ,  131  and  141 , it is determined whether the respective storage elements  41 _ 1 ,  41 _ 2 ,  41 _ 3  and  41 _ 4  are write accessible, meaning not in the process of being written to with data to be decoded and not already full of data to be decoded which have not yet all been decoded. 
   For this purpose, the used_i flag is tested, where i assumes the values of whole numbers between 1 and 4, in the respective steps  111 ,  121 ,  131  and  141 . 
   If it is determined in one of these steps that the corresponding used_i flag is not set (case where used_i=0), meaning the associated storage element  41   —   i  is not currently being used, the algorithm returns to step  71 . 
   Otherwise the flag is set (case where used_i=1), which means that the associated storage element  41   —   i  is currently in use, either being written to with data to be decoded (write access) or already containing data in the process of being decoded but not yet all decoded (read access). In this case, in the respective step  112 ,  122 ,  132 , or  142 , it is determined whether the data stored in the associated storage element belong to the stream S 1  or the stream S 2 . 
   To do this, the mod_i flag is tested, where i assumes the respective values of a whole number between 1 and 4. If the mod_i flag has the value of 1, this indicates that the data stored in the associated storage element belong to the stream S 1 . In this case, the full_i flag is set to 1. 
   Stated otherwise, the fact that the used_i flag is set (used_i=1) and the mod_i flag has the value of 1 (mod_i=1) indicates that
         (i) the associated storage element is full of data to be decoded which have not yet all been decoded, in which case the full_i flag in principle is already set (full_i=1), or that   (ii) this storage element was previously in the process of being written to with data to be decoded associated with a frame which is now completely received, in which case, the full_i flag is not set but should be. This is why, in a respective step  113 ,  123 ,  133  or  143 , the full_i flag is set.       

   As a result, in the case (i) above the full_i flag is left at 1, and in the case (ii) above it is changed from 0 to 1. 
   After the steps  113 ,  123 ,  133  or  143 , the algorithm returns to step  71 . 
   In the right part of  FIG. 9 , steps equivalent to those just described above are illustrated, but these relate to the handling of the full_i flag associated with the storage elements  41   —   i , in the case where the newly received frame belongs to the stream S 2 . These steps are symmetrical with those described above for the frames from the stream S 1 , and therefore do not need to be described again here. One will simply note that the full_i flag is set when the mod_i flag has the value of 2 (instead of the value of 1 as is the case when the newly received frame belongs to the stream S 1 ). 
   The steps in the algorithm for managing the used_i and full_i flags when reading from the storage elements are, in this embodiment, identical to the case in the first embodiment which was described above in reference to  FIG. 7 , and therefore do not need to be described again here. One will simply note that the mod_i flags do not need to be reinitialized at the time of the read operations. Their value is updated, as needed, when the data to be decoded corresponding to a new frame are stored in the associated storage elements. 
   The second embodiment allows decoding a data stream having a higher bit rate than M/2, but obviously less than M. This advantage is obtained at the price of a slightly more complex management (three flags to be managed instead of two for each storage element). 
     FIG. 10  represents blocks of data to be decoded over time (each block represented by a rectangle) from the streams S 1  and S 2 , on the first and second lines respectively, with the horizontal axis representing time. The scheduling of the blocks received and processed by the decoder, corresponding to the stream S 3 , is represented on the third line. In each rectangle, the reference is given for the storage element (buffer) where the block of data is stored. As is illustrated by the arrows, a block of data should be completely received and stored before its decoding begins. 
   Embodiments of the invention have been described above in a non-limiting manner. In particular, embodiments of the invention are not limited by the type of block decoding. In addition, a person skilled in the art will appreciate that embodiments of the invention are not limited by the number of data streams to be encoded, and that some embodiments may provide for decoding more than two distinct streams with the same decoder. In reality, all depends on the bit rates of the decoder in comparison to the bit rates of each of the data streams to be decoded or the sum of each of the data streams to be decoded. Furthermore, the management algorithms are non limiting, in particular an algorithm for circular allocation of storage elements for writing can be envisaged. 
   All of the above U.S. patents, U.S. patent application publications, U.S. patent applications, foreign patents, foreign patent applications and non-patent publications referred to in this specification and/or listed in the Application Data Sheet, are incorporated herein by reference, in their entirety. 
   The above description of illustrated embodiments, including what is described in the Abstract, is not intended to be exhaustive or to limit the invention to the precise forms disclosed. While specific embodiments and examples are described herein for illustrative purposes, various equivalent modifications are possible within the scope of the invention and can be made without deviating from the spirit and scope of the invention. 
   These and other modifications can be made to the invention in light of the above detailed description. The terms used in the following claims should not be construed to limit the invention to the specific embodiments disclosed in the specification and the claims. Rather, the scope of the invention is to be determined entirely by the following claims, which are to be construed in accordance with established doctrines of claim interpretation.