KR20020089310A - Viterbi decoding with path metric update implemented in the order of bit-slices - Google Patents

Abstract

The present invention relates to a bit-slice implementation of ACS operation for a Viterbi decoder suitable for software implementation in a digital computer. The first bit-slice is formed of a single word with the LSB of the path measurement for all states, and the second bit-slice is formed of the next most significant bit and thus goes to the MSB. The addition of the ACS operation is performed in bit-slice units starting with the addition including the LSB of the path measurement. Moreover, the comparator of the ACS operation is performed using subtraction on a bit-slice basis. Therefore, the present invention enables path measurements for all states to be updated at the same time, provides faster speed improvement than the prior art, and one bank of path measurements is used.

Description

VITERBI DECODING WITH PATH METRIC UPDATE IMPLEMENTED IN THE ORDER OF BIT-SLICES}

Bit errors often occur when data is transmitted through media such as radio waves, infrared rays, or the magnetic head of a hard disk. Therefore, it is well known to encode data before transmission by adding redundancy to the original data before transmission. When a data stream is received, an appropriate decoder is used to decode the encoded data stream with redundancy to eliminate bit errors. Of course, as more redundancy is added during encoding, more bits have to be transmitted and thus a balance is needed between the amount of redundancy added and the elimination of bit errors resulting as a result of adding redundancy.

One common encoding technique is often referred to as convolutional encoding, which produces an encoded data stream comprising a plurality of codes. When the encoder receives an input to be encoded, for example a data bit, it generates a code according to the received input and a number of previous inputs received by the encoder. The term "limit length" refers to the number of inputs that a convolutional encoder uses to generate an output code. For example, if the limit length "k" is 7, this means that the output code generated by the convolutional encoder depends on the current input and the previous six inputs. Thus, it will be appreciated that for each input there are 2 ^k-1 previous states that the encoder can have.

There are many other uses for this type of encoding. For example, hard disk drives, mobile phones, digital audio broadcasting (DAB) radios. An example of a DAB-related standard is the "Radio Broadcasting System" set by the European Telecommunications Standard Institute (ETSI) ETS 300 401, May 1997 (Second Edition) standard; digital audio broadcasting to mobile, portable and fixed receivers (DAB )"to be. In DAB radio, since the encoder's limit length k is 7, there are 64 states that the encoder can have (based on six previous input bits) for each input bit.

If the original sequence of data bits is encoded to create an encoded data stream, the technique needs to be provided to the receiving end to decode the data stream and use redundancy therein to find and correct any errors in the received information. You will know One algorithm often used to perform such decoding is the Viterbi algorithm, which is typically used to convolutionally decode an encoded data stream. A general description of the Viterbi algorithm is described by John G. Proakis in the publication of "Digital Communication", (3rd edition), McGraw-Hill Inc.

In accordance with the Viterbi technique, a table as shown in FIG. 1 is generated. It has an entry for each of the 2 ^k-1 states and is updated upon receipt of each code in the encoded data stream. Thus, as shown in FIG. 1, each entry is originally assumed to have a field 20 indicating a state, a "metric" or score 30 associated with that state, and a state associated with the nearest state. It will have a path history 40 representing a predetermined number of bits that are recognized as bits in the data sequence of.

As each code is entered, the metric 30 for each state must be updated and the state with the "best" metric (e.g., typically the one with the lowest or highest value, depending on the implementation), must follow the correct path. It is selected as having. Thus, the oldest bit in the path history 40 of the state is the output as the correct output for this stage.

Reference is made to FIG. 2 to indicate how the metric is typically updated for each state. This indicates how the new state relates to the previous state. Assuming a certain state is correct, you will know that there are two possibilities for the data used to generate the code output to the encoder because the bits have a logical zero value or a logical one value when a new bit is received by the encoder. will be. If the code is received at the decoder due to the possibility of signal contamination, it is necessary to determine the similarity for each state in Table 10. Similarity here means that the state represents k-1 previous input bits used with the new input bits to generate the code.

Referring to FIG. 2, this represents a state where three previous input bits can be used with a new input bit to generate a code, assuming that the limit length k is four. On the left side of the figure you will see that all eight possible states of the three previous bits are shown. Considering an example of the old state, which is 001, the data on which the code generated by the encoder is based is 0010 or 0011 and therefore the bits needed to generate the transmitted code by comparing these codes with the received code are really 0010 or 0011. You will find that it determines the similarity of cognition. This comparison yields an update value (sometimes referred to as a Hamming distance) that can be used to generate an updated score for the state.

Referring again to Figure 2, once the code is processed, there is the same set of states shown in Table 10, and the way these states relate to the old states is very complex. For example, a new state 010 may have arisen from the previous state 001 or 101. In both cases, the new bit received is zero. Thus, the hamming distance can be generated for each possibility by comparing the received code with the code expected at 0010 and 1010. The metric associated with the old state 001 and the corresponding hamming distance are added to that metric to generate possible update metrics. This process is repeated for the metric associated with state 101. Whichever is considered the highest of the two possible metrics (for example, if the hamming distance is defined to increase as a match between two codes becomes worse), it is selected and in state 010 Used as a new metric for. Moreover, the relevant bits are added to the relative path history. For example, if state 010 is thought to have originated from state 001, it may be considered that a logical zero value should be added to the path history for 001. This path history is copied to state 010 as a new path history of that state. Otherwise, if state 010 is not thought to have originated from state 101 it may be considered that a logical 1 value should be added to the path history for state 101. This path history is then copied to state 010 as a new path history for that state.

The above processing is performed for each state in Table 10. The final result is that each metric 30 and path histories are updated. Also, if the path history is already full, the oldest bit in the path history associated with the state with the highest metric may then be output as a bit that is considered to be the correct bit in the original data sequence at this time.

As above, for each state update two metrics need to be added to two Hamming distances (depending on the received code), the smaller of the two (assuming the smaller distance is better) and It is stored in association with the updated state. If an output bit is later requested from the decoder, all the metrics are compared and the state with the best metric is considered to be related to the path closest to the original data.

From the above description, since each state update described above requires two metrics added to two Hamming distances in order to compare two results and select one of them, the largest part of the process is to update each state. To be determined. This process needs to be repeated for each state in Table 10.

It is therefore an object of the present invention to provide an improved technique for updating the metric for each state.

Summary of the Invention

In a first aspect, the present invention provides an encoded data stream comprising a plurality of codes each dependent on a first predetermined number of previous data bits and a current data bit in an original sequence and representing an original sequence of data bits. A method of decoding, comprising: (a) providing, for each of a plurality of possible states of a first predetermined number of previous data bits, a score indicating a degree of similarity in which the corresponding state represents the first predetermined number of previous data bits; (B) arranging the scores in a first order, receiving a code (c), and each of the two possible values of current data in the received code, wherein the state is the first Based on the received code representing a predetermined number of bits, two update values representing the similarity are determined for each state. (D) storing a first plurality of score bit slices each comprising a predetermined bit from each of said scores so as to collectively represent the scores as arranged in step (b); (F) storing a second plurality of score bit slices each including a predetermined bit from each of the rearranged scores to rearrange the scores to collectively represent the rearranged scores; (G) generating a first plurality of update bit slices for a score bit slice and a second plurality of update bit slices for the second plurality of score bit slices from the update value, and the first plurality of score bits A first candidate plurality of updated score bit slices from a slice and the first plurality of update bit slices (H) generating a second candidate plurality of updated score bit slices from the second plurality of score bit slices and the second plurality of update bit slices, and for each score represented by a bit slice. (I) generating a plurality of updated score bit slices by applying bits to the first candidate plurality of updated score bit slices or the second candidate plurality of updated score bit slices by applying a predetermined criterion to And a score, wherein all the scores are updated at the same time.

Rather than updating the scores for each state one at a time, the present invention allows the scores for all states to be updated at the same time. In the prior art approach each score is stored in a separate word. According to the invention, however, simultaneous updating of scores is achieved by bit slicing the relevant values required for the calculation. Thus, in accordance with a preferred embodiment of the present invention, the lowest digit bits of the score for all states are together in a single word (which may constitute multiple machine words, for example multiple 32-bit machine words, depending on the number of states). Is taken, the next highest bit of the score of all states is taken in another word, and so on. Therefore, considering the example where each score is required to have 8 bits of accuracy, an eight bit slice is typically provided that takes all the scores. This bit slicing technique is described below by way of example with reference to the following two tables. Table 1 shows the prior art, with scores a, b, c, d,. , z is stored in a separate word. Table 2 shows the bit slicing techniques of the preferred embodiment, where each word ("bit slice") contains a predetermined bit from each score.

According to the present invention, the first plurality of score bit slices are stored based on an initial alignment of the scores. However, there are two possible routes for updating any particular state as described above with reference to FIG. According to the present invention, this issue is achieved by collectively representing the rearranged scores such that the scores are reordered and the second plurality of score bit slices are stored so that two separate plurality of score bit slices are designated.

Furthermore, according to the present invention, the update value (e.g. hamming distance) is also stored as a bit slice. The first plurality of update bit slices are generated for the first plurality of score bit slices, and the second plurality of update bit slices are generated for the second plurality of score bit slices.

The first candidate plurality of updated score bit slices are generated from the first plurality of score bit slices and the first plurality of update bit slices, and likewise the second candidate plurality of updated score bit slices is generated from the second plurality of score bit slices. Is generated from the second plurality of update bit slices. In a preferred embodiment, these candidate plurality of updated score bit slices are generated by summing the plurality of score bit slices and the plurality of update bit slices together.

According to the present invention, a first step of applying a predetermined criterion to determine whether for each individual score a score should be selected from a first candidate plurality of updated score bit slices or a second candidate plurality of updated score bit slices Is employed. This will produce a final plurality of updated score bit slices that reflect all the updated scores so that all the scores appear to be updated at the same time.

In a preferred embodiment, the method of the present invention is implemented in software and provides a significant potential improvement over known prior art because it updates all scores simultaneously.

In a preferred embodiment, upon receiving more codes from the encoded data stream, the plurality of updated score bit slices are treated as the first plurality of score bit slices and the update used in step (g) based on the further code. Steps f to i are repeated with the value.

As already described with reference to FIG. 2, in known prior art systems the metrics are not rewritten in the same state in which they are read, and indeed several metrics may overlap. For this reason, a typical prior art uses two banks of metric and path history. One set is used for writing and the other is used for reading. Once all states are updated they are exchanged. In this prior art the positions of the states remain the same and the metric is shifted. For certain states n and N states, Viterbi is:

Metric [n * 2] is the metric [n] or metric [n + N / 2].

Metric [n * 2 + 1] is the metric [n] or metric [n + N / 2].

This can be seen, for example, from the example of FIG. 2 when N is 8 and n varies from 0 to 7.

Therefore, storing all of the scores as a plurality of bit slices will appear to cause a lot of complexity, since at the end of each update all bits in each bit slice need to be turned. However, in accordance with an embodiment of the present invention, in each iteration, the plurality of updated score bit slices are treated as the first plurality of score bit slices without any rearrangement of bits in each bit slice and the scores are only rearranged so that 2 form a plurality of score bit slices. Assuming that each code in such a preferred embodiment is k-bit dependent, the state represented by the individual scores contained within the plurality of updated score bit slices changes during each iteration of steps f-i8. This approach therefore keeps at least one set of metrics in the same position without maintaining the state at the same position as in the prior art, and the nominal states represented by the metric change during each iteration. However, within a relatively repeated number of iterations the score is initially aligned.

In a preferred embodiment, the record remains as indicated by the individual scores for each iteration of k-1. Thus, knowing that the iteration is being performed, one can determine which state relates to which particular score.

In a preferred embodiment, reordering the scores in step (f) depends on the particular iteration. However, in the preferred embodiment, since the first plurality of score bit slices are not rearranged, reordering the scores to form the second plurality of score bit slices is not the complex fanning out motion described above with reference to FIG. 2. It was found to simply include linear reordering of the metric. Thus, in a preferred embodiment of the present invention, the number of operations required to perform the reordering is considerably less than what is required to keep in mind the complex reordering referred to in the prior art.

In a preferred embodiment, step (d) is performed prior to decoding the encoded data stream to generate a lookup table of update bit slices for each k−1 iterations. Thus, in step g, the update bit slice is read from the lookup table based on the code received, the iteration, and whether the update bit slice is the first or second plurality of score bit slices. In the preferred embodiment the score reverts to the initial alignment following k-1 iterations, and it is clear that there are only finite possibilities for the update bit slice. Thus, it is possible to generate a lookup table that provides all possible update bit slices, eliminating the need to generate the update bit slices during the decoding process. The size of the lookup table depends on the number of possible received codes, the number of iterations, and the number of bit slices needed to represent the update value. However, for practical examples such as DAB radios, you can see that the lookup table is quite small. For example, considering DAB radio, the number of repetitions is 6 since k = 7. Furthermore, since the code is 4 bits long, the update value is represented by 3 bits and a 3 bit slice is required. This means that for each of the first and second plurality of score bit slices used in the update process, there are 288 (16 code × 6 stage × 3 bit slice) update bit slices that need to be stored in the lookup table, i.e. a total of 576 update bit slices. do.

In a preferred embodiment step (i) includes subtracting the second candidate plurality of updated score bit slices from the first candidate plurality of updated score bit slices to form a path history. The path history bits for a particular score represented by a plurality of updated score slices are selected according to the value of the bit at that position in the path history bit slice. In a preferred embodiment the path history bit slice includes carry out values from the subtraction. Thus, if the first plurality of updated score bit slices are represented by M _A , and the second candidate plurality of updated score bit slices are represented by M _B , then a zero value at a particular location within the path history bit slice is M _A. in that the score is displayed and that is greater than the corresponding score in M _B and the logical value of 1 indicates that the corresponding score in M _B is greater than the score in M _a. Therefore, based on the value within the path history bit slice, it can be seen that the score to be used in the last plurality of updated score bit slices generated in step (i) can be determined.

In a preferred embodiment, the path history bit slice is added to a path history that includes a plurality of path history bit slices. The path history is employed to determine a second predetermined number of bits that are considered bits in the original sequence prior to the first predetermined number for any particular state. In such an embodiment there is no need to refer to the previous path history bit slice at this stage and thus the path history bit slice can simply be added to the path history without having to read any previous path history bit slices at that point. This is a particularly effective way to update path history.

Since individual path histories are not moved during each iteration and the state is allowed to go around (because at least one score bit slice is not rearranged), it is difficult to track the path history for any particular state. Can be. However, in the preferred embodiment each path history bit slice is associated with one of the k-1 iterations so that a second predetermined number of bits can be determined for any particular state with reference to the record. Therefore, it is apparent that the necessary information is useful for the tracking to take place. Moreover, in the preferred embodiment, if the path history is allowed to be longer than when others, the trace may be delayed until there are many output bits. So the overhead of tracing is lower per output bit. In a preferred embodiment of the present invention, the performance of updating the path history is not affected by the remaining length of the path history since the path history is simply updated by adding a new path history bit slice without the need to read the path history at that stage.

Therefore, in the preferred embodiment the scores are compared to select the score that best meets the given criteria in the given time period. A state corresponding to the score is determined, and a plurality of the second predetermined number of bits for that state are determined and output as the decoded portion of the original sequence of data bits.

In a second aspect, the present invention provides encoded data that includes a plurality of codes, each dependent on a first predetermined number of previous and current data bits in the original sequence, the encoded data representing the original sequence of data bits. 12. A system for decoding a stream, comprising: a score generator for each of a plurality of possible states of a first predetermined number of previous data bits providing a score indicating a degree of similarity in which the corresponding state represents the first predetermined number of previous data bits; A sorter that arranges the scores in a first order, and each of the two possible values of current data in the received code upon receipt of the code, wherein the status indicates the first predetermined number of bits For each state two update values representing the similarity based on the generated code And an update value generator for determining, wherein the score generator is arranged to collectively represent the scores sorted from the beginning as a first plurality of score bit slices, and includes a predetermined bit from the score in each of the score bit slices. And the sorter is arranged to reorder the scores, the score generator is arranged to collectively represent the reordered scores as a second plurality of score bit slices, wherein each score bit slice is from each of the reordered scores. And a predetermined bit, wherein the update value generator is configured to update the first plurality of update bit slices for the first plurality of score bit slices and the second plurality of update bit slices for the second plurality of score bit slices. Generated from a value, each The update bit slice of represents a predetermined bit from certain ones of the update values, and the score generator is configured to generate a first candidate plurality of updated scores from the first plurality of score bit slices and the first plurality of update bit slices. Generate a bit slice, generate a second candidate plurality of updated score bit slices from the second plurality of score bit slices and the second plurality of update bit slices, and generate a predetermined value for each score represented by the bit slice. Apply a criterion to generate a plurality of updated score bit slices by selecting bits for the first candidate plurality of updated score bit slices or the second candidate plurality of updated score bit slices, wherein all scores are updated simultaneously. Original sequence characterized It provides a system for decoding the encoded data stream representing.

In a third aspect, the present invention provides a computer program operable to constitute a computer processing unit for performing the method of the first aspect. It will be appreciated that the term computer processing unit means any computing device capable of executing a computer program. Thus, for example, it may be a conventional microcomputer, a dedicated logic unit, or the like.

In a fourth aspect, the present invention provides a recording medium comprising the computer program of the third aspect. The recording medium may be, for example, a storage device such as a CD-ROM, a diskette, a RAM, a ROM, or the like. Alternatively, the recording medium may be another medium of a telecommunications infrastructure, in which a computer program is delivered, for example, having a facility for electronically distributing the computer program over the Internet.

The present invention is a method of a system and method for decoding an encoded data stream.

The invention is further illustrated by reference to the preferred embodiment as described in the accompanying drawings below.

1 is a table that may be generated for possible states in accordance with a known implementation of the Viterbi decoding technique,

2 is a diagram illustrating how a metric moves during an update operation in accordance with known prior art;

3 is a diagram illustrating how metrics and states move during an update operation in accordance with a preferred embodiment of the present invention;

4 is a block diagram showing the basic components of a DAB receiver to which the technique of the preferred embodiment of the present invention may be applied;

FIG. 5 is a block diagram structurally showing functional configurations in the decoder of FIG. 4 in accordance with the description of the preferred embodiment of the present invention; FIG.

6 and 7 are flow charts illustrating the processing performed within the decoder of FIG. 4 in accordance with the techniques of the preferred embodiment of the present invention.

In contrast to the typical prior art approach in which the metric for each Viterbi state is updated at one time, the preferred embodiment of the present invention provides a technique in which all metrics are updated at the same time. This simultaneous update of the metric for each state as described above is accomplished by "bit slicing" the relative value required for the calculation. However, as is apparent from FIG. 2 above, the metric must move between complex radial arrangements of updates to keep the position of the state the same. This implies that when updating the metric for each state, all bits within each bit slice need to be moved.

However, in accordance with a preferred embodiment of the present invention, at each update iteration, a set of metrics is allowed to be in the same place, and the nominal state represented by the metric changes as it is repeated. This process is shown in Fig. 3, which is a possible state assuming that the limit length k is 4, as in Fig. 2, and therefore three previous input bits are used together with the new input bits to generate a transport code.

It will be seen with Figure 2 that all eight possible states of the three previous bits are shown. In each update iteration, referred to as stage 0, stage 1, and stage 2, one set of metric bit slices is located in the same place as the horizontal line refers to. If necessary, another set of metric bit slices (to be compared with the first set) must move. However, as is apparent from FIG. 3, this movement is linear, not including the radial shown in FIG. 2. In a typical implementation it can be seen that this reduces the number of operations required to reorder three per word length bit slice.

It is important to note from FIG. 3 that after each update stage the nominal state represented by a particular metric in the set of metric bit slices typically changes, but the state represented by the metric bit slices is after the k-1 stage. Return to their original order. Thus, in the example shown in FIG. 3 with k = 4, the states revert to their initial order after three stages. Similarly for DAB radios with k = 7, the state returns to their initial order after six stages.

Given a limited number of different stages, it can be seen that after completion of a particular stage it is relatively straightforward to keep track of the stage represented by a particular metric into a set of metric bit slices. In particular, for stage n, in stage i (i has a value between 0 and k-2), the bit for the metric representing state n is the bit position n in each bit slice (the bit position starts at bit position 0). >> i) n >> i represents n rotating by i bits on the right side surrounded by bit k-2. This is evident from FIG. 3. If we consider state 010, the bits of the metric at stage 0 will be at bit position 010, i.e. bit position 2, and at stage 1 the bits of the metric will be at bit position 001, i.e. bit position 1, stage 2 The bit of the metric at will be in bit position 100, ie in bit position 4. After these three (ie k-1) stages, state 010 returns to its initial order (ie bit position 2).

When generating the updated score bit slices as described above, two different plurality of score bit slices are used, and the bits in the first plurality of score bit slices (hereinafter abbreviated as M) remain in their original order, The bits in the second plurality of score bit slices (abbreviated as M _X hereinafter) move linearly as shown in FIG. 3. In a preferred embodiment, M _X is calculated as follows. k is the limit length and i (0, ..., k-2) is the number of stages.

set:

s = (k-2)-I;

shift = 2 μs (s);

mask = a mask of 2 ＾ (k-1) bits as follows:

Bit j in mask set if bit s is a set of j

(Ie, the mask is a repeating pattern of 'shift' 0s followed by 'shift' 1s).

MX = ((M << shift) AND mask) OR ((M >> shift) AND N0T mask)

In a preferred embodiment, in addition to arranging the metrics in the bit slice format, the hamming distances are also arranged as bit slices. Assuming there is typically a limited number of stages before the state returning to the initial order, there will only be a limited number of possible Hamming distance bit slices. Thus, in the preferred embodiment these bit slices are predetermined and stored in a lookup table used during the decoding process. The following equation shows how a particular Hamming distance bit slice is obtained from the lookup table.

Hamming distance <bit slice> = lookup table [received code] [stage] [bit slice] [M or M _X ]

As described above, since k = 7 for the DAB radio, the number of stages is 6 and the code is 4 bits long. Moreover, since the Hamming distance is represented by 3 bits, there is a 3-bit slice to be obtained from the lookup table for any particular set of Hamming distances needed for the update operation. Based on the above equation there are 576 possibilities of Hamming distance bit slices so these can be stored in advance in the lookup table.

According to a preferred embodiment of the present invention, if the state is not static and moves between stages, this may seem to significantly increase the complexity of the tracking process required to read the bits of the path history. However, in the preferred embodiment, since the path history does not need to be loaded to update it, the path history is also stored as a bit slice, which significantly reduces the path history update overhead. Instead, the new path history bit slice is only written to the end of the history buffer. However, there are some additional complications involved in tracking, since the path history does not move to follow the movement of the state between stages. However, in the preferred embodiment this is somewhat weakened by providing a slightly larger history buffer, delaying tracing and generating multiple output bits as a result of a single tracing process. If the path history is allowed to be longer, the trace can be delayed until there are multiple bits to be output, so the overhead of the trace is lowered for each output bit. In a preferred embodiment, the path update is handled as a sequence of bit slices and each path history bit slice is simply added to the end of the history buffer without having to be loaded into the path history at that stage, so that the updating of the path is the remaining length of the path history. Not affected by

Having discussed a general discussion of the technique of the preferred embodiment, a discussion of the implementation within the DAB radio receiver will be described in more detail with reference to FIGS. 4 and 5. 4 is a block diagram illustrating basic functional blocks provided in a DAB receiver. A convolutionally encoded radio signal is received at antenna 105 and passed through a demodulator and digitizer circuitry 100 to demodulate the signal and convert the analog to digital. Those skilled in the art will appreciate that this circuit portion is well known. Therefore, it is not described further here. The digitized signal is passed to a decoder 110 where the decoding process of the preferred embodiment of the present invention is performed to generate a sequence of data bits to be output to the radio receiver circuitry 120. As will be appreciated by those skilled in the art, the radio receiver circuitry 120 may be provided by one of a number of well known receiver circuitry. Therefore, it is not described herein any further. The output of the radio receiver circuit 120 is inversely converted into an analog signal by the digital-to-analog converter 130 before being output to the speaker 140.

5 is a block diagram conceptually illustrating main function components in the decoder 110 according to an exemplary embodiment of the present invention. Storage 240 represents a generic storage accessible to decoder 8 110. This storage 240 stores the data required by the score generator 210 and may have the form of a cache, RAM, DRAM, etc., or a combination of such storage devices. Thus, the current score bit slice, the path history bit slice, and the reference of the current iteration stage (and thus of the current order of state) may be stored in the storage 240. The score generator 210 collectively represents a score (or metric) in a first plurality of score bit slices. Furthermore, the sorter 200 is arranged to respond to the information provided by the score generator associated with the iteration stage to reorder the scores and feed the rearranged scores to the score generator so that the second plurality of score bit slices are used during the update process. To be able.

The update value generator 220 accesses the lookup table 230 in response to the score generator 210 to receive the hamming distance bit slice to be used by the score generator 210. The score generator will refer to the update value generator 220 if iterative stages and bit slices are required for the first plurality of score bit slices or the second plurality of score bit slices. Based on this information and the reference of the received code being decoded, the update value generator 220 accesses the lookup table 230 to obtain a hamming distance bit slice, which is returned to the score generator 210. The lookup table 230 is physically located in the storage 240 or provided separately.

The score generator 210 is responsible for generating a plurality of updated score bit slices and outputting the path history bit slices to the storage 240 to update the path history. Score generator 210 may also perform a tracking routine as required to output multiple bits from the decoder. This tracing begins by determining the best metric (e.g., having the smallest value) and starting with that value in the most recent path history bit slice and in the designation of the iteration stage. The score generator 210 can track through the various path history bit slices by knowing the internal relationship between states from one iteration stage to another (as shown structurally in FIG. 3). This internal relationship is typically stored in a lookup table accessible to score generator 210. The tracking process results from the marking of one or more output bits output to the decoder.

In the preferred embodiment of the present invention, the functions of the sorter 200, score generator 210 and update value generator 220 are well known to those skilled in the art that they are optionally mounted in firmware or hardware, but may be implemented in a microcomputer. Is implemented in software.

The processing performed by the decoder 110 to process each received code and update the metric is described with reference to the flowcharts of FIGS. 6 and 7. Processing begins at step 300. Here two parameters "Stage" and "Count" are set to zero. It is then determined in step 310 whether a new code will be received. Once the new code is received, processing proceeds to step 320 where the metric is updated. This process will be described later in detail with reference to FIG.

Once the metric is updated, the parameter stage is incremented by one in step 330 to determine if the parameter stage is greater than or equal to 6 (ie, k-1) in step 340. If the parameter Stage is greater than or equal to 6, processing branches to step 350 where the metric is renormalized. Then, at step 360 the parameter stage is reset to zero. It is well known to those skilled in the art that there are a number of techniques that may be used to renormalize the metric. This process ensures that no particular metric exceeds the number of bits allocated for storage of each metric. Obviously in step 340 the selected value causing the renormalization for comparison will be selected according to the implementation. So in some implementations you might think of choosing a value other than 6.

If at step 340 it is determined that the parameter Stage is not greater than or equal to 6, processing proceeds to step 370. If the renormalization process is called from step 340, the process proceeds from step 360 to step 370.

In step 370, the parameter Count is incremented by one. Then in step 380 it is determined if the Count is greater than or equal to 60. If Count is not greater than or equal to 60, processing returns to step 310 and waits for receipt of the next code. However, if Count is greater than or equal to 60, the process proceeds to step 390 in which a predetermined number of bits are output by the decoder using the above-described tracking process. Once the predetermined number of bits have been output, the parameter Count is reset to zero in step 395 and processing returns to step 310.

FIG. 7 details the processing performed within the decoder to update the metric in step 320 of FIG.

Beginning at step 410, Hamming distance bit slices for the first plurality of Hamming distance bit slices H _A and the second plurality of Hamming distance bit slices H _B are determined. As described above, the processing is performed by the update value generator 220. Next, in step 420, the first candidate plurality of updated score bit slices M _A are calculated. This calculation includes adding the first plurality of hamming distance bit slices H _A to the first plurality of score bit slices M (ie, the unordered plurality of bit slices). This is accomplished by adding together the individual bit slices for a particular bit position and taking any carry bit to the addition performed on the bit slice for the next bit position.

In step 430, the first plurality of score bit slices M are rearranged to produce a second plurality of score bit slices M _X. Next, at step 440, the second candidate plurality of updated score bit slices M _B is calculated by adding M _X to H _B.

In step 450, M _B is subtracted from M _A to generate a carry out bit slice. Thus, the value of zero in a particular position on the carry-out bit slice will indicate that the corresponding score in M _A is greater than the score in M _B. A logical 1 value will indicate that the corresponding score in M _B is greater than that score in M _A.

This carry out bit slice is used as the path history bit slice for this particular update operation. Thus, in step 460 the carry out bit slice is stored as a path history bit slice that becomes the updated path history. Furthermore, in step 470 a plurality of updated score bit slices M _new are generated by selecting each bit in each bit slice from the corresponding bits of M _A or M _B depending on the path history bit slice. So, for example, assuming a low value of the metric indicates a close match, a zero value at a particular location within the path history bit slice will indicate that the corresponding score from M _B should be used. On the other hand, a logical value of 1 would indicate that the corresponding score from M _A should be used in M _new . Once M _new has been calculated at step 470, processing proceeds to step 480. Where M _new is set equal to the new default metric M to be used in subsequent update processing. This process then proceeds to point B shown in FIG.

It can be seen from the above description that the technique of the preferred embodiment of the present invention provides a particular effect that the metrics for all Viterbi states can be updated at the same time. As mentioned above, this technique may be preferably embedded in software that may be executed on a processor core. The technique of the preferred embodiment of the present invention makes it possible to produce the high bit output required from a decoder using current high end processor cores.

While the preferred embodiments of the invention have been described herein, the invention is not so limited, and many modifications and additions are possible without departing from the scope of the invention. For example, the features of the following dependent claims may be variously combined with the features of the independent claims without departing from the scope of the invention.

Claims (13)

1. A method of decoding an encoded data stream comprising a plurality of codes each dependent on a first predetermined number of previous data bits and a current data bit in an original sequence and representing an original sequence of data bits (A) providing, for each of a plurality of possible states of a first predetermined number of previous data bits, a score indicative of a similarity in which said state represents the first predetermined number of previous data bits; (B) arranging the scores in the first order; Receiving (c) the code; Each of the two possible values of current data in the received code is given, and the two update values indicative of the similarity in each state are based on the received code in which the state represents the first predetermined number of bits. Determining (d) (E) storing a first plurality of score bit slices each comprising a predetermined bit from each said score to collectively represent a score as arranged in step (b); (F) storing a second plurality of score bit slices each including a predetermined bit from each of the rearranged scores to rearrange the scores to collectively represent the rearranged scores; (G) generating a first plurality of update bit slices for the first plurality of score bit slices and a second plurality of update bit slices for the second plurality of score bit slices from the update value; Generate a first candidate plurality of updated score bit slices from the first plurality of score bit slices and the first plurality of update bit slices, and from the second plurality of score bit slices and the second plurality of update bit slices Generating (h) a second candidate plurality of updated score bit slices, A plurality of updated score bits by selecting bits for the first candidate plurality of updated score bit slices or the second candidate plurality of updated score bit slices by applying a predetermined criterion to each score represented by a bit slice Generating (i) a slice; And all the scores are updated at the same time. According to claim 1, Upon receiving more than one code from the encoded data stream, a plurality of updated score bit slices are treated as the first plurality of score bit slices and with the update value used in step (g) based on the more code. And the steps (f) to (i) are repeated. The method of claim 2, Each code depends on k bits, and during each iteration of steps (f) through (i) the states represented by each score included in the plurality of updated score bit slices change, and the scores and (f) returns to said initial order following the k-1 iterations of (i). The method of claim 3, wherein A record is maintained in said states represented by each score for each said k-1 iterations. The method according to claim 3 or 4, Said reordering of said score in said step (f) is dependent on a particular iteration. The method according to any one of claims 3 to 5, The step (d) is performed before decoding the encoded data stream to generate a lookup table of update bit slices for each k-1 iterations, wherein in step (g) the update bit slice is And read from the lookup table according to whether the input code, the iteration and the update bit slice are for the first plurality of score bit slices and the first plurality of score bit slices. The method according to any of the preceding claims, The step (i) subtracts the second candidate plurality of updated score bit slices from the first candidate plurality of updated score bit slices to form a path history bit slice, and by the plurality of updated score bit slices. And said bit for a particular score appearing is selected according to said value of said bit to a corresponding position in said path history bit slice. The method of claim 7, wherein A path history bit slice is added to a path history comprising a plurality of path history bit slices, the path history being a second predetermined number of bits considered to be bits in the original sequence preceding the first predetermined number for any particular state. Decoding method for determining the bit. The method according to claim 8, which is dependent on claim 4, Wherein each path history bit slice is associated with one of the k-1 iterations such that the second predetermined number of bits can be determined with reference to the record for any particular state. The method according to claim 8 or 9, The scores are compared at predetermined intervals to select the score that best satisfies a predetermined criterion, a state corresponding to the score is determined, a plurality of the second predetermined number of bits for the state are determined, And output as the decoded portion of the original sequence of data bits. A system for decoding an encoded data stream comprising a plurality of codes, each dependent of a first predetermined number of previous data bits and a current data bit in an original sequence, and representing an original sequence of data bits. A score generator for each of a plurality of possible states of a first predetermined number of previous data bits, the score generator providing a score indicating a similarity indicating the first predetermined number of previous data bits; A sorter for arranging the scores in the first order, Two update values representing each of the two possible values of current data in the received code upon receipt of the code, wherein the status indicates the similarity based on the received code representing the first predetermined number of bits. An update value generator for determining each state for each state, The score generator is arranged to collectively represent a score sorted from scratch as a first plurality of score bit slices, and includes a predetermined bit from the score of each of the score bit slices, The sorter is arranged to reorder the scores, the score generator is arranged to collectively represent the reordered scores as a second plurality of score bit slices, each score bit slice being predetermined from each of the reordered scores. Contains a bit, The update value generator generates a first plurality of update bit slices for the first plurality of score bit slices and a second plurality of update bit slices for the second plurality of score bit slices from the update values, each of An update bit slice represents a predetermined bit from certain of said update values, The score generator generates a first candidate plurality of updated score bit slices from the first plurality of score bit slices and the first plurality of update bit slices, and the second plurality of score bit slices and the second plurality of score bit slices. Generate a second candidate plurality of updated score bit slices from the update bit slices, A plurality of updated score bits by selecting bits for the first candidate plurality of updated score bit slices or the second candidate plurality of updated score bit slices by applying a predetermined criterion to each score represented by a bit slice A slice, wherein all scores are updated at the same time. A computer program operable to construct a computer processing unit for performing the method of any one of claims 1 to 10. A record carrier comprising the computer program of claim 12.