TECHNICAL FIELD
[0001] The present invention relates generally to optical communication systems, and in particular to systems and methods for error correction and data recovery in a coherent receiver.
BACKGROUND
[0002] In the field of data communications, it is well known that data can be lost or corrupted during transmission between a sender and a receiver. Typically, the reliability of the communications network is characterised by the Bit Error Ratio (BER), which measures the ratio of erroneously received bits (or symbols) to the total number of bits or symbols transmitted. It is very desirable to achieve error-free customer bits after decoding in the presence of as high of a noise as possible. The key metric is the Energy per customer bit (E
_{b}) divided by the noise variance N
_{0}, that is: E
_{b}/N
_{0}, expressed in decibels (dB).
[0003] Various known methods are used to detect and correct data transmission errors, and thereby minimize the BER. An important category of techniques for correcting transmission errors is known as Forward Error Correction (FEC).
[0004] Forward Error Correction (FEC) techniques involve processing the data prior to transmission, to generate parity (or check) symbols that may be used at the receiver to detect and correct erroneously received data. Well known FEC schemes include, but are not limited to, Turbo codes, Low-Density Parity Check (LDPC) codes, Block Turbo codes, Reed Solomon codes and BCH codes. For the purposes of the present description, a set of parity (or check) symbols generated over a block of data is referred to as a parity vector, irrespective of its actual format or representation.
[0005] As is known in the art, FEC techniques have an advantage that they avoid the need for storing and resending data packets, but at a cost of increased overhead.
[0006] It is desirable to minimize the overhead, and have a very high noise tolerance, which has led to the use of iterative sparse-graph FEC techniques such as Turbo codes and LDPC codes. However, these techniques suffer from a problem in that a decoded frame may contain residual errors that cannot be corrected by the selected FEC scheme. This problem may arise due to either channel effects (such as cycle slips) or limitations of the FEC algorithm itself, and normally affects a minority of the frames comprising a given signal. However, even when most of the frames are correctly decoded, a small number of decoded frames with significant residual errors can raise the BER of the signal as a whole. Within limits, the error-correction performance of iterative FEC techniques can be improved by increasing the number of iterations implemented by the decoder. However, there is a lower limit to the BER that can be achieved by these techniques, which cannot be further reduced by additional iterations. This lower limit is referred to as an "error floor". In the case of Turbo codes and LDPC codes, for example, error floors in the range of 10
^{-4} to 10
^{-10} are often encountered, which is unacceptably high for many users of optical transmission systems. Code designs that maximize error correction performance at high noise levels (low signal to noise ratio (SNR)) often raise the error floor. For high speed optical communications systems, hardware implementations of the FEC decoder are required, but this also raises the error floor.
[0007] US patent application
US2013/0191696 A1 describes a FEC technique in which a super-frame comprises N-frames including a set of two or more data frames and a parity frame that is calculated across the set of data frames. Each bit of the parity frame is calculated using at least one bit from each one of a plurality of the data frames. With this arrangement, if any one of the N frames of the superframe fails to converge in the FEC decoder, then the errored frame can be recovered based on the other N-1 correctly decoded frames in the super-frame. This technique is beneficial in that it increases tolerance to "error bursts" characterised by a large number of errored bits within a single frame, and also has a very low error floor compared to conventional techniques. However, it has been found that this technique does not significantly improve E
_{b}/N
_{0}. Furthermore, US patent application
US2008/0294966 A1 discloses a coding scheme comprising an intra-frame coding part and a diagonal inter-frame coding part.
[0008] The problem to be solved is how to optimize the Energy per customer bit (E
_{b}) divided by the noise variance N
_{0}, (that is: E
_{b}/N
_{0}), while minimizing the error floor.
[0009] Techniques for data recovery that overcome limitations of the prior art remain highly desirable.
SUMMARY
[0010] The above-noted problem is solved by error correction methods and systems having the combination of elements defined in appended claims 1, 11 and 14.
[0011] Disclosed herein are techniques for error correction and data recovery in an optical communications system. Accordingly, the invention concerns a method of forward error correction according to claims 1 to 10, a forward error correction encoder according to claims 11 to 13, and a forward error correction decoder according to claims 14 and 15. Further aspects related to the invention are summarized below.
[0012] An aspect provides a method of forward error correction. The method comprises a FEC encoder: processing a data signal to generate a sequence of FEC frames; and computing a plurality of parity vectors such that each parity vector spans a plurality of the FEC frames, a subset of N, where N is an integer, N>0, bits of a FEC frame is allocated to each one of at least two parity vectors, and a respective location of the subset of N bits from a given FEC frame within one parity vector is different than the respective location of the subset of N bits from the FEC frame within another parity vector, such that the plurality of parity vectors are staggered with respect to a sequence in which the FEC frames are processed.
[0013] In some aspects, a respective different subset of N bits of a FEC frame is allocated to each one of at least two parity vectors.
[0014] In some aspects, N is less than the Hamming distance of at least one of the plurality of parity vectors.
[0015] In some aspects, at least one of the plurality of parity vectors is computed using an encoding scheme that is different than the encoding scheme used to compute another one of the plurality of parity vectors.
[0016] In some aspects, at least one of the plurality of parity vectors is computed using a binary Single Parity Check, SPC, encoding scheme. The respective subset of N bits may comprise a subset of rows or columns of a rectangular product FEC frame. Optionally, the respective subset of rows or columns may be dis-contiguous. Optionally, the respective subset of rows or columns associated with a first parity vector are interleaved with the respective subset of rows or columns associated with at least one other parity vector.
[0017] In some aspects, a given parity vector is associated with a respective different subset of rows or columns in each of the FEC frames.
[0018] In some aspects, at least one of the plurality of parity vectors is computed using a Low Density Parity Check, LDPC, encoding scheme. Optionally, the respective subset of N bits may be distributed across the FEC frame.
[0019] In some aspects, the method may further comprise a FEC decoder: receiving a plurality of the FEC frames and parity vectors; processing bits of a first parity vector and updating an estimate of at least one bit in a first FEC frame based on the processing result; and decoding the first FEC frame using the updated estimate.
[0020] In some aspects, updating the estimate of at least one bit comprises computing a respective Log Likelihood Ratio, LLR, of the at least one bit.
[0021] In some aspects, processing bits of a first parity vector comprises: deducing values of parity bits of the first parity vector corresponding to a subset of bits of a first FEC frame that has been successfully decoded; and calculating a local Log Likelihood Ratio, LLR, of parity bits of the first parity vector corresponding to a subset of bits of a second FEC frame that has not been successfully decoded. Optionally, the FEC frames residing in the FEC decoder exchange their respective locally calculated LLR information through one or more parity vector decoders. Optionally, the parity vector decoders include bits from at least one of the FEC frames which is in a decoding stage of FEC decoder. Optionally, updating the estimate of at least one bit in the first FEC frame comprises computing the sum of an LLR of the at least one bit and the processing result.
[0022] A further aspect provides a Forward Error Correction encoder comprising: a processor configured to process an input data signal to generate a sequence of FEC frames; and a parity calculator configured to compute a plurality of parity vectors such that: each parity vector spans a plurality of the FEC frames, a subset of N, where N is an integer, N>0, bits of a FEC frame is allocated to each one of at least two parity vectors, and a respective location of the subset of N bits from a given FEC frame within one parity vector is different than the respective location of the subset of N bits from the FEC frame within another parity vector, such that the plurality of parity vectors are staggered with respect to a sequence in which the FEC frames are processed.
[0023] In some aspects, at least one of the plurality of parity vectors is computed using either one of binary Single Parity Check (SPC) encoding scheme and a Low Density Parity Check, LDPC, encoding scheme.
[0024] A further aspect a Forward Error Correction decoder comprising: a buffer configured to receive a plurality of FEC frames; and a processor configured to process bits of a first parity vector and update an estimate of at least one bit in a first FEC frame based on the processing result; and decode the first FEC frame using the updated estimate.
[0025] In some aspects of the decoder, the processor is configured to estimate at least one bit in a first FEC frame by: deducing a value of decoded data bits of a first FEC frame associated with a first parity vector having an effective length of one FEC frame, based on known values of parity bits of the first parity vector; and for each parity vector having an effective length corresponding to more than one FEC frame, updating a Log Likelihood Ratio, LLR, of each unknown parity bit associated with the first FEC frame based on known and unknown parity bit values of each parity vector.
[0026] Some aspects provide a method and apparatus of forward error correction. A FEC encoder: processes a data signal to generate a sequence of FEC frames, and computes a plurality of parity vectors. Each parity vector spans a plurality of the FEC frames. A respective subset of systematic bits of each FEC frame is associated with a corresponding subset of parity bits in each one of the parity vectors. Finally, a respective location of the parity bits associated with a first FEC frame in one of the parity vectors is different from the respective location of the parity bits associated with the first FEC frame in another one of the parity vectors.
[0027] Further aspects provide a method and apparatus in which a FEC decoder receives a plurality of FEC frames and parity vectors. A value of decoded data bits of a first FEC frame associated with a first parity vector having an effective length of one frame are deduced based on known values of parity bits of the first parity vector. For each parity vector having an effective length corresponding to more than one FEC frame, a Log Likelihood Ratio (LLR) of each unknown parity bit associated with the first FEC frame is updated based on known and unknown parity bit values of each parity vector. The first FEC frame is decoded using the deduced decoded data bit values and the updated LLR of each unknown parity bit associated with the first FEC frame.
BRIEF DESCRIPTION OF THE DRAWINGS
[0028] Representative embodiments of the invention will now be described by way of example only with reference to the accompanying drawings, in which:
FIG. 1 schematically illustrates a representative optical communications system in which methods in accordance with the present invention may be implemented;
FIG. 2 schematically illustrates relationships between data frames and parity vectors in accordance with a first representative embodiment of the present invention;
FIG. 3 schematically illustrates relationships between data frames and parity vectors in accordance with a second representative embodiment of the present invention;
FIG. 4 schematically illustrates relationships between data frames and parity vectors in accordance with a third representative embodiment of the present invention;
FIG. 5 schematically illustrates relationships between data frames and parity vectors in accordance with a fourth representative embodiment of the present invention;
FIG 6 schematically illustrates computation of extrinsic LLR values; and
FIG 7 schematically illustrates updating LLR values of parity bits associated with a FEC frame using the extrinsic LLR values of FIG. 6.
[0029] It will be noted that throughout the appended drawings, like features are identified by like reference numerals.
DETAILED DESCRIPTION
[0030] In very general terms, there are provided techniques in which a set of two or more parity vectors are computed across a plurality of data frames in a staggered manner relative to the sequence of the data frames, such that as each data frame is processed in sequence by a FEC decoder, the effective length (ie the number of unconverged random variables) of each of the parity vectors are reduced at different times. The shorter the parity vector, the more information it contains about each of the random variables that remain within it. A simple parity vector having an effective length of L=1 is entirely known. The information from a parity vector may be used to improve the Log Likelihood Ratio (LLR) of data bits within it that have not yet converged in the FEC decoder.
[0031] FIG. 1 schematically illustrates a representative optical communications system 2 of the type in which methods in accordance with the present technique may be implemented. As may be seen in FIG. 1, a FEC encoder 4 associated with a transmitter 6 may comprise a signal processor implementing a desired FEC scheme to process an input data stream to generate FEC frames, comprising encoded data and parity symbols, as will be described in greater detail below. The FEC frames are then passed to the transmitter 6 for transmission through the system to the receiver 10. Similarly, a FEC decoder 8 associated with a receiver 10 may comprise a signal processor implementing appropriate decoding and frame reconstruction operations using the received FEC fames.
[0032] The signal processors at the transmitter and receiver ends of the system 2 may be implemented by any suitable combination of hardware and/or software such as, for example, a general purpose computer programmed using suitable software. However, using current technology, software-based solutions are expected to be too slow. Accordingly, in preferred embodiments, the signal processors are implemented entirely in hardware, for example using field Programmable gate Arrays (FPGAs) or Application Specific Integrated Circuits (ASICs). In some embodiments, the signal processor may be implemented as two or more processor blocks pipelined together.
[0033] FIG. 2 is a block diagram illustrating staggered parity in accordance with the present technique. In the example of FIG. 2, a series of nine FEC frames (F(-2), F(-1), F(0) ... F(6)) are shown arranged in sequence. In this example, the index (t) identifies the temporal order in which the FEC frames F(t) are generated by the FEC encoder 4, but other indexing schemes could equally be used to identify each FEC frame. In some embodiments, a plurality of FEC frames F(t) may be buffered in sequence to facilitate computation of the parity vectors, but this is not essential. In principle, any desired FEC encoding scheme, such as the known BCH may be used to encode the data signal to generate the FEC frames F(t). Parity vectors with a single added parity bit (simple parity) are used in these descriptions, for simplicity. Other parity equations may be used.
[0034] As is known in the art, a FEC frame typically comprises "systematic bits" representing the encoded data, and "syndrome bits" representing parity (or check) bits. Typically, the syndrome bits within a FEC frame relate to the systematic bits of that frame, and are substantially independent of the systematic and syndrome bits of any other FEC frames. The present technique departs from this common scenario in three ways. First, the syndrome bits are calculated using a block of data that spans multiple frames, and so the syndrome bits within any given frame relate to systematic bits or more than one frame. (Advantageously, the syndrome bits in a frame are separated into two sets, with the first set being due to parity vectors across frames, and the second set being due to FEC equations applied to bits within that frame, including the bits of the first set.) Second, multiple sets of syndrome bits are calculated in parallel using a respective subset of the data bits of any given frame, and the union of those subsets contains at least most of the bits in that frame. For simplicity in this description, any bits not participating can be considered to be not part of the frame. This means that, within any given frame, the syndrome bits are divided into groups, each of which belongs to one of a plurality of parity vectors, and relates to a respective subset of the systematic bits of other frames. Advantageously, each parity vector contains at most one bit from a given frame. Finally, the parity vectors are staggered in time, relative to the sequence of the frames, so that each group of syndrome (and/or possibly systematic) bits within a given frame occupies a respective time location within its parity vector that is different from the location occupied by at least three other groups of syndrome (and/or possibly systematic) bits within its parity vector. FIG. 2 schematically illustrates this arrangement with a specific example where different parity groups inside each FEC frame reside in different location with respect to the starting FEC position within their own parity vector. (For simplicity of visualization, in this example the time order is identical to the bit ordering in a parity vector.) This means that upon decoding FEC frames in time, each FEC frame takes the advantage of having parity vectors with a range of different effective lengths due to either the known values of contributing bits to each parity vector from previously converged FEC frames or their high level of LLR confidence due to partial convergence. This helps each FEC frame to observe an "averaged" effective parity length which is much smaller than "L".
[0035] Referring to FIG. 2, there is shown a set of frames F(t), in which t represents the temporal order in which the frames are generated by a FEC encoder, and thus the nominal order in which the frames in which the frames are decoded in order to recover the original data stream. Also shown in FIG. 2 is a set of parity vectors P(x,y) computed by a FEC encoder. In the figure, x is an index that identifies the temporal order of a block of parity vectors, and y is an index that identifies an individual parity vector within a given block. As may be appreciated, the use of x and y indexes for referencing parity vectors is not essential, but rather is selected for convenience of description and ease of understanding. In fact, any suitable means of referencing parity vectors may be used. Indeed, it is not necessary to consider parity vectors as being grouped into defined sets or blocks, although in some cases it may be convenient to do so.
[0036] As may be seen in FIG. 2, each parity vector P(x,y) is computed over a block of data bits that spans a set of seven frames. However, in general, different parity blocks may have different length. In some embodiments, it is convenient to indicate the length L of each parity vector P(x,y) in terms of the number of frames that it encompasses. In this case, the parity vectors P(x,y) of FIG. 2 all have a length of L=7. Other suitable metrics of parity vector length may be used, if desired. In practice, it has been found that parity vector lengths less than about L=5 tend to be inefficient, whereas increasing simple parity vector lengths beyond about L=20 increases complexity (and thus cost) of encoding and decoding with little additional performance gain compared to shorter vectors. A compromise of length of between L=12 and L=17 has been found to provide acceptable performance with reasonable processor complexity, but the present technique is not limited to any particular range of parity vector lengths.
[0037] As may be seen in FIG. 2, within any given block of parity vectors (for example P(0,y), 0 ...y...6) the parity vectors are staggered in time, such that each successive parity vector P(0,y) begins one frame later than the previous parity vector P(0,y-1). Hence, as the FEC frames are decoded in time either sequentially or partially in parallel, parity vectors with large number of bits coming from past FEC frames, will get the most advantage by improving their parity information (or equivalently, reducing their effective length). However, as parity vectors are staggered in time, each FEC frame benefits with the same portion from the shortened length parity vectors. In principal, any suitable encoding scheme, (such as, for example, a binary Single Parity Check (SPC) product code, or Low Density Product Code (LDPC)) may be used to calculate each parity vector and each FEC equation. In some embodiments, all of the parity vectors are generated using the same encoding scheme, such as Single Parity Check (SPC). In other embodiments, different encoding schemes may be used to generate different ones of the parity vectors. For example, in some embodiments it may be desirable to compute LDPC FEC equations, and SPC parity vectors.
[0038] For convenience of illustration, each of the parity vectors P(x,y) in FIG. 2 are arranged in rows. In some embodiments, it may be convenient to compute the parity vectors in this manner. For example, a rectangular product code scheme generates FEC blocks which are commonly considered as a rectangular frame of m rows and m columns. In some embodiments, m=127, but other values are equally possible. In such embodiments it is convenient to use a set of M parity vectors, and sub-divide the FEC frame into M subsets of m/M rows. Each subset of m/M rows of the frame can then be assigned to a respective one of the M parity vectors. In some embodiments, each parity vector contains parity bits computed using the same row (or subset of rows) of each of its FEC frames. In other embodiments, each parity vector contains bits from a respective different row (or subset of rows) of each of its FEC frames. Other patterns can also be defined, as desired.
[0039] In the example embodiment illustrated in FIG. 2, M=7,and each parity vector P(x,y) is computed over a respective subset of m/7 rows of L=7 consecutive frames F(t). In addition, each parity vector P(x,y) contains parity bits computed using the same row (or subset of rows) of each of its FEC frames. Thus, for example, parity vector P(1,0) may contain parity bits computed from rows 0-13 of each one of frames F(1) ... F(7), while parity vector P(1,1) contains parity bits computed from rows 14-27 of each one of frames F(2) ... F(8), and so on.
[0040] FIG. 3 illustrates an example embodiment in which M=7, L=7, and each parity vector P(x,y,z) is computed over a respective subset of rows of L=7 consecutive frames F(t). In this embodiment, the index z (1..,z...L-1) identifies a respective portion of a given parity vector. Thus, for example, parity vector P(1,0,z) comprises L=7 portions or sub-blocks, each of which contains parity bits calculated using systematic bits of a respective one of frames F(1) ... F(7). In the embodiment of FIG. 2, the bits which construct a parity vector are all selected from the same relative position inside their corresponding FEC frames. Therefore the individual portions are not shown. The embodiment of FIG. 3 differs from the arrangement of FIG. 2 in that each portion z of a given parity vector P(x,y) contains bits selected from different parts of each FEC frame. Thus, for example, parity vector P(1,0,z) contains parity bits computed from a first portion of FEC frame F(1); the 2
^{nd} portion of FEC frame F(2); the 3
^{rd} portion of FEC frame F(3), etc. For ease of understanding, the pattern of traced by the parity vectors across FEC frames F(-1) to F(8) are illustrated using arrows, which extend from a first portion P(x,y,0) to a final portion P(x,y,L-1) of each parity vector.
[0041] The examples described above with reference to FIGs. 2 and 3 allocate a respective subset of rows of a FEC frame F(t) to each parity vector P(x,y,z). It will be appreciated that systematic bits of each FEC frame can be allocated to parity vectors in other patterns. For example, each parity vector P(x,y,z) may be associated with a subset of columns of a frame, rather than rows. The rows (or columns) of systematic bits allocated to each parity vector do not need to be contiguous, but rather may be interleaved with the rows (or columns) allocated to other parity vectors. The allocation of rows (or columns) of systematic bits to each parity vector is particularly suited to SPC codes. Other encoding schemes may be implemented with different patterns of systematic bits being allocated to each parity vector. For example, LDPC codes may be computed using systematic bits distributed across the entire frame F(t). In some embodiments, there are M parity vectors, and every M
^{th} systematic bit of a FEC frame is allocated to a respective one of the parity vectors.
[0042] As noted above, an important feature of the present technique is that the parity vectors are staggered with respect to the sequence of FEC frames, such that any given FEC frame occupies a respective different time portion of each parity vector. Thus, in the example of FIG. 2, FEC frame F(0) occupies the last position of parity vector P(0,0), and the next-to-last position of parity vector P(0,1). Additionally, the effective length L' of any given parity vector drops to L'=1 at a different time than that of other parity vectors. As will be described in greater detail below, these features significantly reduce error floors, and improve E
_{b}/N
_{0}.
[0043] In the embodiments described above with reference to FIGs. 2 and 3, the parity vectors are non-overlapping. That is, a given subset of bits of each FEC frame are associated with only one parity vector. FIG. 4 shows an embodiment in which parity vectors are at least partially overlapping. In the embodiment of FIG. 4, each frame is divided into M=6 subsets of m/M rows, which are labeled as F(x,y), where x is an index that identifies the frame, and y (y=0...M-1) is an index that identifies each subset of rows. Each subset is assigned to a parity vector, following the pattern shown by the arrows in FIG. 4. In the example of FIG. 4, the length of each parity vector is L=8. This length is larger than the number of bits (or subsets of bits) inside each FEC frame. This means that at least some of the bits of each frame contribute to two or more parity vectors. As an example, the portion F(0, 1) contributes to two parity vectors which extend to portions F(4, 5) and F(7, 5), respectively. Staggered parity is designed such that bits of each FEC frame which observe a large effective length of their associated parity vector benefit from information of multiple parity vectors. As an example, considering FEC frame F(0) and assuming previous FEC frames (i.e. F(-1), F(-2), ...) are decoded, the FEC frame portion F(0, 1) is associated with two parity vectors having effective lengths of 5 and 8 respectively. Combining the independent information coming from the 2 parity vectors helps to significantly improve LLR quality of F(0, 1). The FEC portions F(0, 5), F(0, 4) are not associated with multi-parity vectors because their effective parity vector length is already small, and it has been found to be advantageous to have more equal sharing of the strengthening across the bits.
[0044] The embodiments described above describe staggered parity with a sequence of FEC frames where parity vectors are staggered in time.
[0045] In some embodiments, it might be suitable to have multiple parallel FEC sequences in time where parity vectors are staggered on exactly one of the parallel FEC sequences. Such embodiments would be preferable for hardware decoder engines capable of processing many parallel FEC frames.
[0046] In some embodiments, it would be beneficial to stagger each parity vector not only in time, but also across parallel FEC sequences. Such designs are favorable to avoid high dependence of decoding performance of each FEC frame on the decoding performance of previous FEC frames. Moreover, such staggering across sequences would help to increase the minimum Hamming distance of valid codeword sequences across multiple FEC sequences, and as a result, reducing the FEC error floor.
[0047] As an example, FIG. 5 depicts an embodiment in which 2 parallel sequences of FEC frames are generated. In this figure, the bits constructing each parity vector are staggered in time. However, at least some of the parity vectors are also interleaved across the two FEC sequences. As an example, the bits constructing parity vector P(2) (i.e. P(2, 0), P(2, 1), P(2, 2)) all reside in the 1
^{st} FEC sequence. However, the bits constructing the parity vector P(9) (i.e. P(9, 0), P(9, 1), P(9, 2)) are selected across two FEC sequences. In particular, portions P(9, 0) and P(9, 2) of parity vector P(9)are selected from the 1
^{st} FEC sequence, while portion P(9, 1) is selected from the 2
^{nd} FEC sequence.
[0048] Referring back to FIG. 2, consider a scenario in which FEC frame F(0) of FIG. 2 is currently being processed by the FEC decoder. FEC frames F(-1), F(-2) etc. have already been processed, and FEC frames F(1) - F(6) are buffered and awaiting processing by the FEC decoder. The parity bits within each parity vector may be classified into three states, namely:
State 1: A random variable where the Log Likelihood Ratio (LLR) value is available and is a valid estimate and being improved in time by FEC decoder. Parity bits in State 1 are those bits associated with a FEC frame that is currently being processed by the FEC decoder. In FIG. 2, parity bits associated with FEC frame F(0)are in state 1.
State 2: A random variable where a static noisy LLR value due to the received channel value is known. Parity bits in State 2 are those bits associated with FEC frames that have been buffered, but have not yet arrived at the FEC decoder for processing and improvement and convergence to the stable known values through the FEC decoder. In FIG. 2, parity bits associated with FEC frames F(1) - F(6) are in state 2.
State 3: A formerly random variable where the bit value is now known with certainty. Parity bits in State 3 are those bits associated with FEC frames that have already been successfully decoded. In FIG. 2, these are FEC frames received and successfully processed prior to FEC frame F(0), that is, any of frames F(-1), F(-2) ... etc. that have been successfully decoded.
[0049] As noted above, while a FEC frame is being processed, the parity bits associated with that frame are in state 1. If a FEC frame is known to have converged to be error free, then all of the parity bits associated with that block are in state 3. FEC frames that have been buffered but not yet arrived to the processing hardware have parity bits in state 2.
[0050] For any given parity vector, if one or more bits are in state 2, then the bits are not known with certainty, but a meaningful update of any LLR value is still possible using that parity vector. The shorter the effective length L', the more meaningful the update can be. However, as more bits of a parity vector enter state 3, the effective length L' of that parity vector is reduced, and this reduction in the effective length can be used to improve the overall decoding performance. In fact, when the effective length reaches L'=1, then the remaining (i.e. state 1 or 2) bits of that parity vector can be entirely deduced from those bits of the parity vector that are already in state 3.
[0051] For any one parity vector and any one frame, the number of bits from that frame that are part of that vector can be denoted as N. It is advantageous to have N small so that a burst of errors in one unconverged block has a bounded effect on the parity vectors. Generally, N should be less than the Hamming distance between valid vectors, known as the Hamming distance of the vector. For an SPC this means that N<2 is desirable.
[0052] For example, consider a scenario in which the FEC decoder has already successfully decoded FEC-frames prior to frame F(0) (that is, frames F(-1), F(-2) ... etc). At the start of decoding frame F(0), the associated parity bits within parity vector P(0, 0) are already entirely known as for each bit, because all of the other bits of that parity vector have are already known (i.e. are in state 3) by virtue of the FEC decoder having successfully decoded the previous FEC frames. Consequently, decoded data bit values of frame F(0) associated with parity vector P(0, 0) can be directly deduced from parity vector P(0, 0) and the known data bits of the previously decoded frames F(-6) ...F(-1). The known values of the data bits within frame F(0) can be used to improve both the probability of successfully decoding the entire frame F(0) and to speed the frame decoding process by reducing the number of iterations required to achieve convergence of the frame.
[0053] Furthermore, parity vector P(0, 1) has an effective length of L'=2 as previous bits (associated with previously decoded frames F(-5)...F(-1)) are already known. More generally, the bits of FEC frame F(0) associated with parity vector P(0, m) observe an effective parity vector length L'=m, because only "m" bits from the remaining FEC-frames F(0),F(1)..,F(m-1) remain in either of states 1 or 2.
[0054] Averaged over all of the parity vectors, each FEC frame F(t) observes an averaged effective parity vector length of about L'=L/2. This reduced effective parity vector length improves the LLR of each data bit in the frame, thereby achieving an overall improvement in FEC decoder performance. In fact, the gain will be much higher than the Bit Error Ratio (BER) gain after decoding a parity vector of length L, as the FEC decoder is operating on Parity vectors with a mixture of different length from L'=1...L. In some embodiments, the staggered parity in accordance with the present technique can yield an E
_{b}/N
_{0} as much as 1dB better than conventional FEC methods.
[0055] In practice, it is possible that there may be a number of consecutive FEC frames F(0), F(1), F(2) being decoded simultaneously. This could arise due to: I) Different FEC frames might require different number of iterations (and therefore time) to be decoded depending on their SNR quality, and there may be a limited memory buffer at the input of FEC decoder, and II) There may be multiple parallel decoding engines within the FEC decoder, each of which may be used for decoding FEC frames consecutively. The techniques described below are tolerant of this simultaneous decoding situation.
[0056] It is contemplated that staggered parity in accordance with the present technique may be implemented using suitable modifications to conventional FEC encoder/decoder hardware and software, and that such modifications will be well within the purview of those of ordinary skill in the art based on the teaching of the present disclosure. Accordingly, detailed descriptions of conventional FEC encoder/decoder hardware and software will not be presented herein. Rather, the following description will focus on the important features of staggered FEC, so that the ordinarily skilled reader will be able to modify a conventional FEC encoder/decoder to implement techniques in accordance with the present invention. The following description describes representative staggered parity encoder operation for an example case in which Single Parity Check (SPC) parity vectors are computed for FEC frames generated using BCH(113, 127,5) encoding.
[0057] For FEC-frame F(t), let us assume t=L*k + p, where 0<=p<L. In other words,
t ≡
p (
modulo L). We have:
[0058] Where r is an index that identifies a row of the frame F(t). Notice that in the above equation the summation operation (∑) is applied modulo 2. Furthermore,
F(
t,
r) is a vector of length equal to the length of a row in the FEC frame (i.e. 127 in the case of BCH(113, 127,5) encoding), so the summation is indeed vector summation. Finally, └
x┘ is the floor function which is defined as the largest integer number y where y≤x.
[0059] Notice that as
F(
τ,
r) is a valid BCH codeword, their summation modulo 2 is also a valid BCH codeword. Hence,
F(
t,r) is a valid BCH codeword. Hence, it is not necessary to generate the syndrome bits for the r'th row of Frame F(t), as its syndrome bits will be automatically calculated by the summation.
[0060] FIG. 2 shows the flow of staggered parity vectors in time for the case of L=7. Notice that in this example a 112x127 submatrix of each BCH(113, 127,5) encoded FEC frame is allocated to a set of M=7 SPC parity vectors. As may be seen in FIG. 2, the length of each SPC parity vector is L. Furthermore, the SPC parity vectors are staggered in time relative to the sequence of the FEC frames. With this arrangement, the effective rate of FEC is equal to
The reason is that we intentionally ignored the negligible rate difference due to CRC's and the fact that we apply Simple Parity over the first 112 rows of each frame.
[0061] The benefit of staggered parity can be observed from FIG. 2. In the decoder, as FEC frames are decoded in time, the number of unknown bits in each unsolved parity vector is reduced, which helps the FEC decoder to successfully decode the next FEC frame.
[0062] In order to get a better understanding, let us assume that the FEC decoder already decoded FEC-frames F(-1), F(-2)...etc. successfully. At the start of decoding F(0), parity vector P(0, 0) has an effective length L'=1, and consequently the parity bits in the portion of parity vector P(0, 0) associated with frame F(0) are entirely known as for each bit, because all other bits of that parity vector (associated with frames F(-1), F(-2), F(-3) etc.) have already been decoded. Since the parity vector P(0, 0) is completely known, values for each data bit of frame F(0) associated with parity vector P(0, 0) can be directly deduced from the already known parity bits. In the case of SPC codes, the "unknown data bits" of F(0) associated with parity vector P(0, 0) can be deduced by summing the known bits of the parity vector P(0,0). This reduces the number of data bits of frame F(0) that need to be decoded by the FEC decoder, which both reduces the number of iterations required for the FEC frame to converge, and (because at least some of the bits of the frame are already known) increases the likelihood that that the FEC frame will converge.
[0063] Furthermore, the bits which belong to P(0, 1) observe an effective parity vector of length L'=2 (rather than L) because previous bits (associated with frames F(-1), F(-2) etc.) have already been decoded to state 3 successfully. In general, the data bits of frame F(0) which belong to the parity vector P(0, m) observe an effective parity vector length of L'=m, since only "m" bits from the remaining FEC frames F(0),F(1)..,F(m-1) are not yet resolved. So, by applying SPC extrinsic operation, an improvement is seen in uncoded BER and mutual-information at the input of the FEC decoder. In fact, the gain will be much higher than the BER gain after decoding a parity vector of length "L" as there are a mixture of parity codes with respective different effective lengths from L'=1...L. Notice that a parity vector with an effective length L'=0 is deterministically known at the input to the decoder.
[0064] For example, consider an arbitrary SPC parity vector of length L, which consists of parity bits: b(1),b(2),b(3)...b(i)...b(L) . We can divide the set of bits to 3 subsets: S(Past), S(Active) and S(Future). The subset S(Active) comprises the subset of parity bits which are currently being decoded by the FEC decoder, as so correspond with the State 1 bits described above. S(Past) comprises the subset of parity bits which have previously been determined by the FEC decoder, either successfully or with an error, and so correspond with the State 3 bits described above. S(Future) comprises the subset of parity bits which have been buffered, but are not yet started being decoded by the FEC decoder. Thus the subset S(Future) comprises bits that correspond with the State 2 bits described above. Although the subset S(Future) has not started being processed, the respective uncoded LLR values of these bits are recorded in the input buffer memory. So, we have
[0065] For each bit b(i) where
b(
i) ∈
S (
Active)∪
S(
Future)
, we have the received channel (input) LLR which we can denote as R(i). Furthermore, for each bit b(i) belonging to
S(
Active), extrinsic LLR values can calculated by a row decoder BCH and a column BCH decoder, and may be denoted as Wr(i) and Wc(i), respectively, as may be seen in FIG.6. Finally, for bits b(i) where
b(
i) ∈
S(
Past)
, the decoded values are already available, and may be denoted as C(i). In addition, the FEC decoder also generates extra information indicating whether or not the data bits corresponding to b(i) have been decoded successfully.
[0066] Based on the above definitions, an intrinsic LLR input vector NR=[NR(1),NR(2),...,NR(L)] can be supplied to the FEC decoder. As may be seen in FIG.7, the intrinsic LLR input vector NR may be calculated as follows:
[0067] Based on the input intrinsic LLR vector NR, we can calculate extrinsic SPC LLR information (which may be denoted as Wp(i) ) for bits b(i) which belong to S(Active). Different approaches may be used to calculate the extrinsic SPC LLR information Wp(i), including a Min-Max Approach, and a Sum-Product approach. Both of these approaches are described below.
[0068] The Min. Max. Approach for extrinsic SPC LLR update calculates extrinsic LLR values Wp(i) by choosing the maximum terms in the nominator and denominator of the LLR expression. The result may be formulated as:
[0069] Notice that in the above formula, the min
_{j≠i}|
NR(
j)| can be calculated by just having the minimum value and 2
^{nd} minimum value in the set as follows. Assume the minimum value and 2
^{nd} minimum value between NR(i=1..L) is calculated
and NR(j
_{0})=m
_{0} and
Furthermore, let us pre-calculate
Then, we have:
[0070] The Sum Product Approach for extrinsic SPC LLR update calculates extrinsic LLR values Wp(i) exactly (i.e. with no approximations) by including all terms inside the nominator and denominator of the LLR expression. The result is:
∀
i,b(
i) ∈
S(
Active):
[0071] Notice that in both approaches described above, it is possible to significantly simplify the terms in the equation by pre-calculating the contributing term coming from any bits within the subsets S(Future) and S(Past). In other words, for bits belonging to S(Past), only their decoded LLR sign-bit value are required (i.e. their LLR magnitude values are not required). Furthermore, for bits belonging to or S(future), their LLR magnitude and sign value are not modified as long as their corresponding FEC frame is not sent to FEC decoder. Hence, it is possible to pre-calculate their contribution in the equation as a fixed term which does not need to be updated in every SPC decoding iteration. In other words, their contributing factor would be modified as soon as they are fetched to the FEC decoder from the input buffer. For example, using the Min-Max approach, it is possible to pre-calculate:
[0072] Notice that the value of m
_{f} and s
_{f} needs to be updated only when a FEC frame is stored in or removed from the input buffer.
[0073] The same approach may be used to simplify contributing terms in the Sum-Product approach. For this purpose, we can use the same term s
_{f} for sign contributor factor and a new term m
_{f} which is equal to.
[0074] An update algorithm can be described as follows:
- i) Upon fetching bit b(i) out of the input-buffer, we have:
- ii) Upon feeding bit b(i) into the input-buffer, we have:
[0075] In the row and column BCH decoders, the SPC extrinsic information may be utilized as follows:
In the column BCH decoder: NR(i) ← Wp(i) + Wr(i) + R(i)
In the row BCH decoder: NR(i) ← Wp(i) + Wc(i) + R(i)
[0076] Notice that for embodiments in which parity vectors are at least partially overlapping (such as the one depicted in FIG 4), the different extrinsic parity values which are brought from different vectors each bit belong will be added together. As an example, for each bit which belongs to F(0, 1), two parity extrinsic values
Wp_{1}(
i) and
Wp_{2}(
i) are calculated corresponding to the parity vectors it contributes to. Hence, the input for column BCH decoder would be
NR(
i) ←
Wp_{1}(
i) +
W_{p2}(
i) +
Wr(
i) +
R(
i)
. Notice that in some embodiments, one might send extrinsic values of each parity vector to the other one it is overlapping with. As an example, in embodiment of FIG 4, the parity vector which extends from F(-3, 1) to F(4, 5) can send its extrinsic parity values to parity vector which extends from F(0, 1) to F(7, 5), as they have overlapping bits in F(0, 1). However, such designs are not advantageous in practice as they add to complexity and delay of the circuit.
[0077] Although the invention has been described with reference to certain specific embodiments, various modifications thereof will be apparent to those skilled in the art without departing from the scope of the invention as outlined in the claims appended hereto.
1. A method of forward error correction, FEC, the method comprising a FEC encoder:
processing a data signal to generate a sequence of FEC frames; and
computing parity vectors such that
each parity vector spans multiple FEC frames by being computed on systematic bits of more than one frame;
in a given FEC frame, a first set of syndrome bits are due to the parity vectors, and a second set of syndrome bits satisfy FEC equations composed of bits of the given FEC frame including the first set of syndrome bits; and
the parity vectors are staggered with respect to a sequence in which the FEC frames are processed.
2. The method as claimed in claim 1, wherein at least one of the parity vectors is computed using a binary Single Parity Check, SPC, encoding scheme.
3. The method as claimed in claim 1, wherein the bits of a parity vector are computed from a subset of rows or columns of rectangular product FEC frames.
4. The method as claimed in claim 3, wherein the subset of rows or columns are dis-contiguous.
5. The method as claimed in claim 4, wherein the subset of rows or columns associated with a first parity vector are interleaved with the subset of rows or columns associated with at least one other parity vector.
6. The method as claimed in claim 1 or claim 2, wherein at least one of the parity vectors is computed using a Low Density Parity Check, LDPC, encoding scheme.
7. The method as claimed in any preceding claim, further comprising a FEC decoder:
receiving a plurality of the FEC frames and parity vectors;
processing bits of a first parity vector and updating an estimate of at least one bit in a first FEC frame based on the processing result; and
decoding the first FEC frame using the updated estimate.
8. The method as claimed in claim 7, wherein updating the estimate of at least one bit comprises computing a respective Log Likelihood Ratio, LLR, of the at least one bit.
9. The method as claimed in claim 7, wherein processing bits of a first parity vector comprises:
deducing values of parity bits of the first parity vector corresponding to a subset of bits of a first FEC frame that has been successfully decoded; and
calculating a local Log Likelihood Ratio, LLR, of parity bits of the first parity vector corresponding to a subset of bits of a second FEC frame that has not been successfully decoded.
10. The method as claimed in claim 8, wherein updating the estimate of at least one bit comprises computing the sum of an LLR of the at least one bit and the processing result.
11. A Forward Error Correction, FEC, encoder comprising:
a processor (4) configured to process an input data signal to generate a sequence of FEC frames; and
a parity calculator configured to compute parity vectors such that
each parity vector spans multiple FEC frames by being computed on systematic bits of more than one frame;
in a given FEC frame, a first set of syndrome bits are due to the parity vectors, and a second set of syndrome bits satisfy FEC equations composed of bits of the given FEC frame including the first set of syndrome bits; and
the parity vectors are staggered with respect to a sequence in which the FEC frames are processed.
12. The Forward Error Correction encoder as claimed in claim 11, wherein at least one of the parity vectors is computed using a binary Single Parity Check, SPC, encoding scheme.
13. The Forward Error Correction encoder as claimed in claim 11, wherein at least one of the parity vectors is computed using a Low Density Parity Check, LDPC, encoding scheme.
14. A Forward Error Correction decoder comprising:
a buffer (10) configured to receive a plurality of FEC frames; and
a processor (8) configured to
process bits of a first parity vector and update an estimate of at least one bit in a first FEC frame based on the processing result; and
decode the first FEC frame using the updated estimate,
wherein the plurality of FEC frames and the first parity vector were generated by the Forward Error Correction encoder claimed in any one of claims 11 to 13.
15. The Forward Error Correction decoder as claimed in claim 14, wherein the processor is configured to update an estimate of at least one bit in a first FEC frame by:
deducing a value of decoded data bits of a first FEC frame associated with a first parity vector having an effective length of one FEC frame, based on known values of parity bits of the first parity vector; and
for each parity vector having an effective length corresponding to more than one FEC frame, updating a Log Likelihood Ratio, LLR, of each unknown parity bit associated with the first FEC frame based on known and unknown parity bit values of each parity vector,
wherein the effective length of any parity vector is the number of FEC frames associated with unknown bits in that parity vector.
1. Verfahren für Vorwärtsfehlerkorrektur, FEC, wobei das Verfahren einen FEC-Codierer umfasst:
Verarbeiten eines Datensignals, um eine Sequenz von FEC-Frames zu erzeugen; und
Berechnen von Paritätsvektoren, sodass
jeder Paritätsvektor mehrere FEC-Frames überspannt, indem er auf systematischen Bits von mehr als einem Frame berechnet wird;
in einem gegebenen FEC-Frame ein erster Satz von Syndrombits auf den Paritätsvektoren beruht und ein zweiter Satz von Syndrombits FEC-Gleichungen erfüllt, die aus Bits des gegebenen FEC-Frames zusammengesetzt sind, beinhaltend den ersten Satz von Syndrombits; und
die Paritätsvektoren in Bezug auf eine Abfolge versetzt sind, in der die FEC-Frames verarbeitet werden.
2. Verfahren nach Anspruch 1, wobei mindestens einer der Paritätsvektoren unter Verwendung eines binären Einzelparitätsprüfungs-, SPC-, Codierungsschemas berechnet ist.
3. Verfahren nach Anspruch 1, wobei die Bits eines Paritätsvektors aus einem Teilsatz von Reihen oder Spalten von rechteckigen Produkt-FEC-Frames berechnet sind.
4. Verfahren nach Anspruch 3, wobei der Teilsatz von Reihen oder Spalten unzusammenhängend ist.
5. Verfahren nach Anspruch 4, wobei der Teilsatz von Reihen oder Spalten, die einem ersten Paritätsvektor zugehörig sind, mit dem Teilsatz von Reihen oder Spalten verschachtelt ist, der mindestens einem anderen Paritätsvektor zugehörig ist.
6. Verfahren nach Anspruch 1 oder Anspruch 2, wobei mindestens einer der Paritätsvektoren unter Verwendung eines Niederdichtenparitätsprüfungs-, LDPC-, Codierungsschemas berechnet ist.
7. Verfahren nach einem der vorstehenden Ansprüche, weiter umfassend einen FEC-Decodierer:
Empfangen einer Vielzahl der FEC-Frames und Paritätsvektoren;
Verarbeiten von Bits eines ersten Paritätsvektors und Aktualisieren einer Schätzung von mindestens einem Bit in einem ersten FEC-Frame, basierend auf dem Verarbeitungsergebnis; und
Decodieren des ersten FEC-Frames unter Verwendung der aktualisierten Schätzung.
8. Verfahren nach Anspruch 7, wobei Aktualisieren der Schätzung von mindestens einem Bit Berechnen eines jeweiligen Logarithmuswahrscheinlichkeitsverhältnisses, LLR, des mindestens einen Bits umfasst.
9. Verfahren nach Anspruch 7, wobei Verarbeiten von Bits eines ersten Paritätsvektors umfasst:
Ableiten von Werten von Paritätsbits des ersten Paritätsvektors, entsprechend einem Teilsatz von Bits eines ersten FEC-Frames, das erfolgreich decodiert wurde; und
Berechnen eines lokalen Logarithmuswahrscheinlichkeitsverhältnisses, LLR, von Paritätsbits des ersten Paritätsvektors, entsprechend einem Teilsatz von Bits eines zweiten FEC-Frames, das nicht erfolgreich decodiert wurde.
10. Verfahren nach Anspruch 8, wobei Aktualisieren der Schätzung von mindestens einem Bit Berechnen der Summe eines LLR des mindestens einen Bits und des Verarbeitungsergebnisses umfasst.
11. Vorwärtsfehlerkorrektur-, FEC-, Codierer, umfassend:
einen Prozessor (4), der konfiguriert ist, ein Eingabedatensignal zu verarbeiten, um eine Abfolge von FEC-Frames zu erzeugen; und
einen Paritätsrechner, der konfiguriert ist, Paritätsvektoren zu berechnen, sodass
jeder Paritätsvektor mehrere FEC-Frames überspannt, indem er auf systematischen Bits von mehr als einem Frame berechnet wird;
in einem gegebenen FEC-Frame ein erster Satz von Syndrombits auf den Paritätsvektoren beruht und ein zweiter Satz von Syndrombits FEC-Gleichungen erfüllt, die aus Bits des gegebenen FEC-Frames zusammengesetzt sind, beinhaltend den ersten Satz von Syndrombits; und
die Paritätsvektoren in Bezug auf eine Abfolge versetzt sind, in der die FEC-Frames verarbeitet werden.
12. Vorwärtsfehlerkorrektur-Codierer nach Anspruch 11, wobei mindestens einer der Paritätsvektoren unter Verwendung eines binären Einzelparitätsprüfungs-, SPC-, Codierungsschemas berechnet ist.
13. Vorwärtsfehlerkorrektur-Codierer nach Anspruch 11, wobei mindestens einer der Paritätsvektoren unter Verwendung eines Niederdichteparitätsprüfungs-, LDPC-, Codierungsschemas berechnet ist.
14. Vorwärtsfehlerkorrektur-Decodierer, umfassend:
einen Puffer (10), der konfiguriert ist, eine Vielzahl von FEC-Frames zu empfangen; und
einen Prozessor (8), der konfiguriert ist zum
Verarbeiten von Bits eines ersten Paritätsvektors und Aktualisieren einer Schätzung mindestens eines Bits in einem ersten FEC-Frame, basierend auf dem Verarbeitungsergebnis; und
Decodieren des ersten FEC-Frames unter Verwendung der aktualisierten Schätzung,
wobei die Vielzahl von FEC-Frames und der erste Paritätsvektor durch den in einem der Ansprüche 11 bis 13 beanspruchten Vorwärtsfehlerkorrektur-Codierer erzeugt wurden.
15. Vorwärtsfehlerkorrektur-Decodierer nach Anspruch 14, wobei der Prozessor konfiguriert ist, eine Schätzung von mindestens einem Bit in einem ersten FEC-Frame zu aktualisieren, durch:
Ableiten eines Werts von decodierten Datenbits eines ersten FEC-Frames, das einem ersten Paritätsvektor zugehörig ist, der eine effektive Länge eines FEC-Frames aufweist, basierend auf bekannten Werten von Paritätsbits des ersten Paritätsvektors; und
für jeden Paritätsvektor, der eine effektive Länge entsprechend mehr als einem FEC-Frame aufweist, Aktualisieren eines Logarithmuswahrscheinlichkeitsverhältnisses, LLR, jedes unbekannten Paritätsbits, das dem ersten FEC-Frame zugehörig ist, basierend auf bekannten und unbekannten Paritätsbitwerten jedes Paritätsvektors,
wobei die effektive Länge eines beliebigen Paritätsvektors die Zahl von FEC-Frames ist, die unbekannten Bits in diesem Paritätsvektor zugehörig sind.
1. Procédé de correction d'erreur directe, FEC, le procédé comprenant un codeur FEC :
traitant un signal de données pour générer une séquence de trames FEC ; et
calculant des vecteurs de parité de telle sorte que
chaque vecteur de parité s'étende sur de multiples trames FEC en étant calculé sur des bits systématiques de plus d'une trame ;
dans une trame FEC donnée, un premier ensemble de bits de syndrome est dû aux vecteurs de parité, et un second ensemble de bits de syndrome satisfait des équations FEC composées de bits de la trame FEC donnée incluant le premier ensemble de bits de syndrome ; et
les vecteurs de parité sont étagés par rapport à une séquence dans laquelle les trames FEC sont traitées.
2. Procédé selon la revendication 1, dans lequel au moins l'un des vecteurs de parité est calculé en utilisant un schéma de codage binaire de vérification de parité simple, SPC.
3. Procédé selon la revendication 1, dans lequel les bits d'un vecteur de parité sont calculés à partir d'un sous-ensemble de lignes ou de colonnes de trames FEC de produit rectangulaire.
4. Procédé selon la revendication 3, dans lequel le sous-ensemble de lignes ou de colonnes n'est pas contigu.
5. Procédé selon la revendication 4, dans lequel le sous-ensemble de lignes ou de colonnes associé à un premier vecteur de parité est entrelacé avec le sous-ensemble de lignes ou de colonnes associé à au moins un autre vecteur de parité.
6. Procédé selon la revendication 1 ou la revendication 2, dans lequel au moins l'un des vecteurs de parité est calculé en utilisant un schéma de codage de vérification de parité faible densité, LDPC.
7. Procédé selon l'une quelconque des revendications précédentes, comprenant en outre un décodeur FEC :
recevant une pluralité des trames FEC et de vecteurs de parité ;
traitant des bits d'un premier vecteur de parité et mettant à jour une estimation d'au moins un bit dans une première trame FEC sur la base du résultat de traitement ; et
décodant la première trame FEC en utilisant l'estimation mise à jour.
8. Procédé selon la revendication 7, dans lequel la mise à jour de l'estimation d'au moins un bit comprend un calcul d'un rapport de vraisemblance logarithmique respectif, LLR, du au moins un bit.
9. Procédé selon la revendication 7, dans lequel le traitement de bits d'un premier vecteur de parité comprend les étapes consistant à :
déduire des valeurs de bits de parité du premier vecteur de parité correspondant à un sous-ensemble de bits d'une première trame FEC qui a été décodée avec succès ; et
calculer un rapport de vraisemblance logarithmique local, LLR, de bits de parité du premier vecteur de parité correspondant à un sous-ensemble de bits d'une seconde trame FEC qui n'a pas été décodée avec succès.
10. Procédé selon la revendication 8, dans lequel la mise à jour de l'estimation d'au moins un bit comprend un calcul de la somme d'un LLR du au moins un bit et du résultat de traitement.
11. Codeur de correction d'erreur directe, FEC, comprenant :
un processeur (4) configuré pour traiter un signal de données d'entrée afin de générer une séquence de trames FEC ; et
un calculateur de parité configuré pour calculer des vecteurs de parité de telle sorte que
chaque vecteur de parité s'étende sur de multiples trames FEC en étant calculé sur des bits systématiques de plus d'une trame ;
dans une trame FEC donnée, un premier ensemble de bits de syndrome est dû aux vecteurs de parité, et un second ensemble de bits de syndrome satisfait des équations FEC composées de bits de la trame FEC donnée incluant le premier ensemble de bits de syndrome ; et
les vecteurs de parité sont étagés par rapport à une séquence dans laquelle les trames FEC sont traitées.
12. Codeur de correction d'erreur directe selon la revendication 11, dans lequel au moins l'un des vecteurs de parité est calculé en utilisant un schéma de codage binaire de vérification de parité simple (SPC).
13. Codeur de correction d'erreur directe selon la revendication 11, dans lequel au moins l'un des vecteurs de parité est calculé en utilisant un schéma de codage de vérification de parité faible densité, LDPC.
14. Décodeur de correction d'erreur directe comprenant :
un tampon (10) configuré pour recevoir une pluralité de trames FEC ; et
un processeur (8) configuré pour
traiter des bits d'un premier vecteur de parité et mettre à jour une estimation d'au moins un bit dans une première trame FEC sur la base du résultat du traitement ; et
décoder la première trame FEC en utilisant l'estimation mise à jour,
dans lequel la pluralité de trames FEC et le premier vecteur de parité ont été générés par le codeur de correction d'erreur directe selon l'une quelconque des revendications 11 à 13.
15. Décodeur de correction d'erreur directe selon la revendication 14, dans lequel le processeur est configuré pour mettre à jour une estimation d'au moins un bit dans une première trame FEC en :
déduisant une valeur de bits de données décodés d'une première trame FEC associée à un premier vecteur de parité ayant une longueur effective d'une trame FEC, sur la base de valeurs connues de bits de parité du premier vecteur de parité ; et
pour chaque vecteur de parité ayant une longueur effective correspondant à plus d'une trame FEC, mettant à jour un rapport de vraisemblance logarithmique, LLR, de chaque bit de parité inconnu associé à la première trame FEC sur la base de valeurs de bits de parité connus et inconnus de chaque vecteur de parité,
dans lequel la longueur effective de tout vecteur de parité est le nombre de trames FEC associées à des bits inconnus dans ce vecteur de parité.