KR20010082093A - Soft output decoder for convolutional codes - Google Patents

Abstract

PURPOSE: A soft output decoder for convolutional codes is provided, which mitigate the whole memory and processing requirements to decode the convolutional codes without restriction like a turbo decoder and a MAP decoder. CONSTITUTION: According to the method decoding a received convolutionally coded sequence of signals expressed as trellis of block length N, the trellis is divided into windows, and a window of length L of the trellis is selected. And determined state metrics is stored in the end of each window by decoding a part of the trellis using a backward recursion. And a set of known backward recursion state metrics is defined by decoding a part of the trellis in the window using a backward recursion, and the set is stored in a memory. Then, a part of the trellis in the window is decoded using a forward recursion, and then a soft output as to each stage is output by calculating the soft output in each stage of the forward recursion using the forward state metric, the stored backward recursion state metrics and a branch metrics in each stage.

Description

SOFT OUTPUT DECODER FOR CONVOLUTIONAL CODES}

Cross Reference of Related Application

This application discloses US patent applications 09 / 502,132 (inventor: Classon, Schaffner, Desai, Baker, Friend), 09 / 501,922 (inventor: Classon, Schaffner) and 09 / 501,883 (inventor: Classon, Schaffner, Desai). This related application is filed on the same day as this application and assigned to the assignee of the present application, which is hereby incorporated by reference in its entirety.

Field of invention

FIELD OF THE INVENTION The present invention relates generally to communication systems, and more particularly to a soft output decoder for use in a receiver of a convolutional code communication system.

Background of the Invention

Convolutional codes are often used in digital communication systems to protect transmission information from errors. At the transmitter, the outgoing code vector is described using a trellis diagram whose complexity is determined by the constraint length of the encoder. The complexity of the calculation increases as the limit length increases, but the robustness of the coding also increases with the limit length.

In the receiver, an actual soft-decision decoder, such as a known Viterbi decoder, employs a trellis structure to perform an optimal search for the maximum likelihood transmitted code vector. use. However, the Viterbi algorithm is complicated to calculate, and its complexity increases exponentially as the limit length increases. This basically means that Viterbi decoders require a significant amount of memory and processing power for long convolutional codes.

Coders for various communication systems, such as the Direct Sequence Code Division Multiple Access (DS-CDMA) standard IS-95 and Global System for Mobile Communications (GSM), have this long limit. For example, GSM half rate limit length K = 7 and IS-95 limit length K = 9.

Another disadvantage of the Viterbi decoder is that a certain number of calculations must be performed for each code vector regardless of the actual number of errors occurring during transmission. In this way, the Viterbi decoder calculates the same number of times as the error signal received and processes the received signal with little or no transmission error.

More recently, turbo codes have been developed that outperform conventional coding techniques. Turbo cords generally consist of two or more convolutional cords and a turbo interleaver. Turbo decoding is iterative and decodes individual convolutional codes using a soft output decoder. The soft output decoder provides information about each bit position that helps the soft code decoder decode other convolutional codes. Soft output decoders typically use a maximum a posteriori (MAP) decoder that requires backward and forward decoding to determine the soft output. However, due to memory, processing and numerical tradeoffs, MAP decoding is usually limited to suboptimal measures. Both of these variants require both forward and backward decoding for the block.

In future specifications such as third generation partnership project for wireless systems (3GPP), an 8-state turbo code with block length N = 5120 would require 40960 words of intermediate storage, which may not be desirable. have. Future systems (larger frames and more states) require much more memory. In comparison, a Viterbi decoder with N = 5120 and no soft output for 8-state trellis requires less than 100 words of intermediate storage.

There is a need for a soft output decoder that mitigates the overall memory and processing requirements for decoding convolutional code without the same degree of limitations as prior art turbo decoders and MAP decoders.

1 is a trellis diagram for a first prior art soft output decoder technique.

2 is a trellis diagram for a second prior art soft output decoder technique.

3 is a trellis diagram for a third prior art soft output decoder technique.

4 is an enlarged graphical view of the diagram of FIG. 3;

5 is another graphical enlarged view of the diagram of FIG.

6 is a trellis diagram for a soft output decoder technique in accordance with the present invention.

7 is a block diagram of a soft output decoder in accordance with the present invention.

8 is an enlarged graphical view of the diagram of FIG. 6;

9 is a flowchart of a soft output decoder method in accordance with the present invention.

<Explanation of symbols for the main parts of the drawings>

100: cordless phone

102: antenna

104: receiver

106: demodulator

108: frame buffer

110: forward return processor

112: backward return processor 112

The present invention greatly mitigates the memory requirements of prior art turbo decoders, but only slightly increases the computation than the Viterbi decoder. In addition, the present invention minimizes the limitations of prior art turbo decoders and MAP decoders.

In general, block codes, convolutional codes, turbo codes and other codes are graphically represented in trellis in FIG. The maximum a posteriori (MAP) type decoder (log-MAP, MAP, max-log-MAP, constant-log-MAP) is known in the art. Soft forward is provided using a forward and backward Viterbi return generalized to the trellis as shown. The MAP decoder minimizes the decoded bit error probability for each information bit based on all received bits. Conventional MAP decoders of the prior art require memory for use in decoding.

Because of the Markov nature of the encoded sequence (the previous state does not affect the future state or future output branch), the MAP bit probability is derived from the past state (the beginning of the trellis for the current state), It can be divided into the current state (branch metric for the current value) and the future state (the end of the trellis for the current value). More specifically, the MAP decoder performs forward and backward returns to the current state and generates output decisions using past and future probabilities along with current branch metrics. The principle of providing hard and soft output decisions is well known in the art and there are several variations of the above decoding methods.

Most of the soft input-soft output SISO decoders considered for turbo code are described in LR Bahl, J. Cocke, F. Jelinek, and J. Raviv's article "Optical Decoding of Linear Codes for Minimizing Symbol Error Rate", IEEE Transactions on Information Theory, Vol. IT-20, March 1974, pages 284-287, based on the prior art MAP algorithm (BCJR algorithm). Figure 1 shows a trellis diagram of this algorithm for an eight-state convolution code that can be used for a turbo code. As can be seen, the turbo decoder consists of an interleaver and a configuration code, but this configuration code is usually a systematic convolutional code, but may also be a block code. The MAP algorithm not only minimizes the probability of error for an information bit given a received sequence, but also provides a probability that an information bit is 1 or 0 given a received sequence. The BCJR algorithm provides soft output decisions for each bit position, where the influence of soft inputs in the block is divided into effects from past (previous soft inputs), current soft inputs, and future (last soft inputs). Lose. This decoder algorithm requires a generalized forward and backward Viterbi return on the trellis to reach the optimal soft output for each trellis section (stage). These asterory probabilities or more typically the log-likelihood ratios (LLR) of the probabilities are passed between SISO decoding steps in iterative turbo decoding. The LLR for information bit u _t is given by Equation 1 for all bits (t = 1 to N) in the decoded sequence.

In Equation 1, given the received sequence, the probability that the decoded bit is 1 (or 0) in the trellis consists of the product of terms due to the Markov characteristic of the code. The Markov characteristic is that the past and the future are independent of the present. Currently, γ _t (n, m) is the probability of being in state m at time _t and generating a symbol y _t when the previous state at time t-1 is n. This current functions as a branch metric. In the past, α _t (m) is the probability of being in state m at time t at the received sequence {y ₁ , ..., y _t }, and future, β _t (m) is the sequence received from state m at time t The probability of generating {y _{t + 1} , ..., y _N }. The probability α _t (m) may be expressed as a function of α _t-1 (m) and γ _t (n, m) as in Equation 2, and is called forward recursion.

Where M is the number of states. The inverse or backward return to calculate the probability βt (n) from β _{t + 1} (n) and γ _t (n, m) is given by Equation (3).

In Equation 1, the overall asterory probability is calculated by summing over the branches in trellis B ¹ (B ⁰ ) corresponding to u _t = 1 (or 0).

In Equation 1, the LLR needs both forward and backward return to be available at time t. The BCJR method to satisfy this requirement is to calculate and store the total reverse return, and iteratively calculates α _t (m) and Λ _t from t = 1 to t = N using α _t-1 and β _t .

The disadvantage of this decoder is that it must be memorized before processing the entire block of N stages. This not only requires a lot of memory (N section × M state × bits per state), but also causes a signal delay of length N before any information can be output. In the W-CDMA system (N to 5000, M = 8, 13 bits), the required memory is about 0.5 M bits. In a CDMA 2000 system, N is approximately 20000, which requires about 2M bits of memory. If the sequence length is small, memory utilization is generally not a problem. However, memory utilization becomes important when N is large, such as when turbo code performs best.

In terms of complexity, the BCJR method requires NM state updates (M state updates per trellis section, N trellis sections in the code) for reverse return and provides optimal performance. In practice, backward return is performed by the processor for the entire block (shown in Figure 1) and stored in memory. Then, a forward return is performed by the processor, and the result is used with the current state and the stored future state to reach the soft output decision for each stage. In this case, the processor operates twice in each stage, once to remember the backward return state, once during the backward return process (throughput = 1/2).

In order to solve the memory utilization problem, sliding window method and similar deformation methods have been developed. S. Benedetto, D. Divsalar, G.Montorsi, and F. Pollara, "Algorithm for continuous decoding of turbo codes," Electronics Letters, Vol. 32, February 15, 1996, pages 314-315, shows the sliding window technique shown in FIG. 2 (in the following figure, the solid arrow indicates an output with a return but no storage, and the dashed arrow indicates no output and no storage And a hollow arrow indicates a memorized return with no output, the direction of the arrow indicating a forward or backward return). The assumption that the probability of occurrence of all states at time t + P is the same (or unknown) is also used for reverse recovery. To use this assumption, the learning period P must be several times the limit length of the configuration code to provide near optimal performance. Too small a learning period can result in noticeable performance degradation, similar to the effect of 'finite traceback' in conventional Viterbi algorithms.

Sliding window technology does not require any memory, but the computation is complicated. In detail, instead of performing the whole backward return and storing, only a part of the backward return is performed (not remembered) to determine each state. For each current state, the algorithm initiates a future return with an unknown initial state and a learning period P away from the current state. Future probabilities are calculated backwards from an unknown future, not from the end of the known trellis. The length P (learning period) is set such that the future probability is nearly accurate at the point when the partial backward return reaches the current state. P depends on the code rate and the limit length of the code and the expected channel conditions. For example, for an 8-state decoder with 1/2 rate convolutional code, P is generally 16 to 32, where P is a multiple of the limit length. The disadvantage of this decoder is that the partial back return begins with the same probability (unknown state) and iteration is allowed until it reaches the current window. This is a suboptimal algorithm because sliding windows cause degradation in true MAP performance, and have an effect similar to finite regression in conventional Viterbi algorithms, increasing the probability of decoded bit errors. In addition, the processor operates P times (processing capacity 1 / P) in each state, and has an output delay of P. In addition, this algorithm requires P times complexity, which can only be reduced by adding more processing.

The sliding window method can be summarized as follows. That is, when t = 1 to N, the reverse return is calculated starting from the time t + P to the time t, and α _t (m) and Λ _t are calculated from α _{t -1} (m) and β _t . The sliding window method reduces the memory requirement from the NM required by the BCJR method to the smaller amount of memory required for the return. Assuming double buffering, the amount of memory is only 2M, which is negligible for analysis.

However, in order to achieve this memory savings, the complexity of the calculation for backward return is increased by the factor P. The sliding window method is also the next best thing due to the 'finite' window size.

Other decoders of the prior art described in US Pat. No. 5,933,462 to Viterbi et al. (S. Pietrobon and S. Barbulescu's paper "A Simplification of the Modified Bahl et al. Decoding Algorithm for Systematic Convolutional Codes", Int. Symp. On Inform.Theory and its Applications, Sydney, Australia, pages 1073-1077, November 1994, revised January 4, 1996, and S. Pietrobon's article "Efficient Implementation of Continuous MAP Decoders and a Synchronization Technique for Turbo Decoders," Int. Symp. On Inform.Theory and its Applications, Victoria, BC, Canada, pp. 586-589, September 1996), discloses another sliding window technique, which is shown in FIG.

The Viterbi sliding window method saves by increasing the complexity of the calculation of the sliding window method of the prior art by treating it in blocks. The reverse return starts at time t + 2L, and the reverse return value is stored from time t + L to time t. The forward return and output probability calculations are then performed over blocks from time t to time t + L. Memory is reduced from NM to LM, doubling the complexity of computation. The main aspect of initiating a return from an unknown state is the same as for sliding window technology.

This technique requires some memory and is still complicated to compute. This decoder differs from the sliding window technique described above by providing a window that slides forward in blocks instead of one symbol at a time. In detail, the sliding window is defined as a sliding window having a length L equal to the learning period P described above. L is also a multiple of the trellis total length N, and the window slides in steps of length L from the beginning to the end of the trellis. As such, the memory required by the prior art decoder that stored the entire trellis was reduced from N to N / L (typically 3k bits for CDMA2000 and W-CDMA systems when L = 32).

This decoder also uses a learning period starting from an unknown future state, which is the next best thing as described above. Specifically, the forward return is performed by the processor over the length L of the first window starting from the known state of the beginning of the first window L. These forward return states are stored. The processor then defines a known state at the end of the first window by starting backward 2L from where this forward return began and performing a backward return from an unknown state. The processor then performs a second back return from the known state of the end of the first window to the current state, where the soft output is generated using information from the back return and the stored forward return. Once all outputs of the first window are determined, the window slides forward by L, and the process repeats starting from the determined state at the end of the first window.

A disadvantage of this decoder is that the first backward return over the learning period L begins with the same probability (unknown state) and can be repeated over the length L, which is the next best thing as described above. In addition, it is possible to achieve half the processing power by operating the front and rear processors in parallel, but the processor operates three times in each state. The decoder generates an output delay of 2L. In addition, backward return requires twice the complexity, which can only be reduced (increased processing capacity) by adding more processing. In addition, the decoder produces soft outputs in reverse order, which needs to be buffered in auxiliary memory before being output.

4 is an enlarged view of the graph of FIG. 3, in which a time component is added. In operation, at time 0 the front processor performs a forward return over the first window from position 0 to L and stores the information, while over the same period the back processor performs a backward return from position 2L to L At L we define the known state of the end of the first window at position L. Thereafter, a second back return operates from time L to 2L from position L to zero to define the soft output over the first window. At this time, the soft decisions are reversed and output in order (obviously occurring after a delay of 2L), the memory is cleared, the window position slides forward by the length of L, and the process is repeated. Instead, the addition of a backward return processor and memory can increase processing power.

FIG. 5 shows yet another result for the graph of FIG. 3, which uses an additional rear processor. The operation is that at time 0, the front processor performs a forward return over the first window from position 0 to L and stores its information, while over the same period the back processor performs a backward return from position 2L to L to time L This defines the known state of the end of the first window at position L. Thereafter, a second back return operates from time L to 2L from position L to zero to define the soft output over the first window. In parallel with this, the front and additional rear processors begin the second cycle by starting to process the information in the second window (positions L to 2L). At time 2L, the soft decision for the first window is output, while the forward return and back learning period for the second window has already ended. Then, a second backward return to the second window is performed to obtain a soft output of the second window. As can be seen here, this technique doubles the throughput. Using the information of the forward return for the first window, double memory is required to store the forward return for the second window.

The decoder (particularly those of Figs. 4 and 5) has some problems. First and foremost, the soft outputs are created out of order and must be reordered before they are output. To do this, an additional buffer memory is required, and an additional delay is generated to change the order of the outputs. Second, the decoder is the next best thing.

The present invention solves these problems in a novel way. Figure 6 shows a trellis diagram using convolutional decoding in accordance with the present invention. The trellis code is obtained from a convolution coded signal sequence represented by trellis of length N in the communication system shown briefly in FIG. In the radiotelephone 100, as is known in the art, a signal passes through the receiver 104 and the demodulator 106 at the antenna 102. This signal is loaded into the frame buffer 106. The forward return processor 110 and the backward return processor 112 act on the block.

The present invention is an optimal technique in which all returns using the known state for initialization are performed for each window, but in the sense that the unknown value used in the sliding window method of the prior art is an associated learning period, To the previously described sliding window technique of FIG. 5. The present invention divides a block of length N into X length L sections, but not all sections need to have the same length, and is assumed to be the same length for purposes of explanation. As in the prior art, the states of points 0 and N are known. The present invention provides a first backward return over the determined N to L block lengths to store the reverse return at a particular point in time defining the state metric of each window end. Without loss of generality, N / L of inverse values are stored uniformly starting from β _N. Since each index group with the stored β endpoint is defined as a window, the trellis is divided into N / L sections with known β endpoints.

Thereafter, a backward return is performed and stored for L-1 unknown state metrics from the known β value state at the end of each window, and then the forward return causes the soft output to be generated in sequence so that the entire window passes. It can be output immediately without waiting. In particular, the sliding window has a length L and the total trellis length N is defined to be equal to a multiple of L so that the window slides from start to end of the trellis by length L. The present invention is optimal because, unlike the sliding window method of the prior art, all returns start from a known state.

In detail, the back return (using the generalized Viterbi algorithm) starts at the known end of the block and goes to the rear processor 112 until the end of the first window (the start of the first window is already known as the beginning of the block). Is performed by. Only state metrics at the end of each window are stored. These metrics are optimal because they are derived from the known termination state of the block. The back return is then performed by the back processor 112 and stored in the memory 114 starting from the known state at the end of the first window and back to the beginning of the window. The forward return processor 110 then performs a forward return from the known state of the starting point of the window over the length of the window and calculates α _t (m) and Λ _t using β and γ. In parallel, the decoder 116 outputs a soft output decision, which determines the known back return in the memory 114, information from the forward return status metric from the forward return processor 110, and the current branch metric. Is generated using

At the end of the first window, the window slides forward by L and repeats the process for that window and each subsequent window until the entire block is decoded. In the preferred embodiment, when the forward return processor 110 operates within the first window, the backward return processor 112 returns backward from the known state at the end of the next window and vice versa to the beginning of the next window. Decode a portion of the trellis in the next window to define a set of known backward return state metrics in the next window stored in memory 114 when the memory is cleared by the forward return processor 110. And immediately after the current window has been processed, the forward return processor 110 remains available to begin decoding the next window. It should be noted that a separate buffer memory can be used in place of the circular buffer described above. Preferably, the front and back processors operate in parallel until all windows in the block are decoded.

An advantage of the present invention is that the outputs are provided in order and do not require additional buffer memory and can be output when the output is generated. An additional advantage is that the soft output decoder is optimal compared to the prior art. The soft output decoder of the present invention provides half the processing power with an N output delay.

FIG. 8 is an enlarged view of the graph of FIG. 6, with time components added. The operation results in the backward processor performing a first backward return from position N to L at time 0 to define the optimal known state at the end of each window at positions L, 2L, 3L and the like. This results in a first delay of length N-L. From time N-L to N (interval L), a second back return is performed over the first window from position L to O and the information is stored. From time N to N + L, forward return operates from the initial known state from position 0 to L, generating a soft output across the first window using the forward return value, the stored back return value, and the current branch metric. Output During this same time (N to N + L), a separate back return is performed from position 2L to L to be used in the subsequent window and repeated. The present invention calculates each soft output according to a known turbo coding technique such as that disclosed in Bahl et al., Supra (BCJR algorithm).

The advantage of the present invention is that it is optimal and the memory is free when it is output since it is output when the soft output is generated. Also, when the memory is cleared, new information from the backward return to the next window can be cycled into the memory. Thus, the present invention not only eliminates the need for a buffer memory to reorder the outputs required in the prior art, but also halves the memory requirements. Note that you do not need to do this if you have enough memory. In addition, the present invention saves time because the prior art does not need to change the order of the soft outputs upon output generation. It should also be noted that if the output requires a last-in first-out format, the order of the entire process described above can be reversed (mirror-image).

9 is a flowchart illustrating a method 200 for decoding a sequence of received convolutional coded signals represented by trellis of block length N in accordance with the present invention. Trellis diagrams are known in the art. The first step 202 is to split the trellis into a window of length L. Step 204 then decodes the portion of the trellis using a backward return back from the known metric at point N at the end of the block to the end of the first window, storing the predetermined state metric at the end of each window. It is. A generalized Viterbi algorithm is used for the return. The length L is independent of the limit length of the convolutional code, but may be set to a multiple of the limit length for convenience or may be variable. The next step 206 is to select the window of the trellis. Step 208 then decodes a portion of the trellis in the window using the backward return to the beginning of the window, inversely from the known state at the end of the window defined in the decoding step, to return the known backward in the window. It defines a set of state metrics and stores this known set of backward return state metrics in memory. The next step 210 is to decode a portion of the trellis in the window using forward return moving forward and starting from the known state at the beginning of the window. The next step 212 is to calculate the soft output at each stage of the forward return process using the forward return state metric, the branch metric, and the stored back return state metric and output the soft output for that stage. Preferably, the return update and soft output are calculated using one of the MAP algorithms or MAP derivation functions (ie log-MAP, max-log-MAP, constant-log-MAP, etc.).

Once the window is fully decoded, the window can "slide" forward by a distance L, and then the beginning of the window begins at the end of the previous window to start from a previously determined known state. The above steps can be repeated for a new window. This process continues until all windows in the block have been processed. Unlike the prior art, the present invention has the advantage that no special processing is required for the last window in the block.

In a preferred embodiment, a further step is included if a backward return to the next window is performed in parallel with the forward return and output being made in the current window. In other words, processing for the next window begins while the first window is being processed. In particular, the further step includes repeating the above steps, wherein the repeating selection step includes selecting a next window starting at the end of the currently selected window, the repeated steps being in the next window. The decoding and calculating steps for the step take place in one step and in parallel with the processing of the current window. This additional step saves processing time and eliminates the need for additional memory. More preferably, while the forward return to the first window is being performed, the stored memory is cleared, and the back return of the window is then stored or cycled to the cleared portion of the memory.

Table 1 summarizes the memory, processing power and computational requirements of the three prior art methods along with the preferred two-pass method of the present invention. However, the main advantage of the present invention is that unlike the prior art sliding method, it provides an optimal solution and other optimal solution, which requires much less memory than the BCJR method of the prior art.

Comparison of Four Methods for Backward Return Way Need memory Processing power Calculation Complexity BCJR NM Word 1/2 NM status update Sliding window 0 word 1 / P LNM Status Update Viterbi Sliding Windows ML word 1/2 2NM Status Update The present invention word 1/2 2NM Status Update

To illustrate the differences between the methods, Table 2 shows the results when using typical values of sequence length (N = 5000), number of states (M = 8) and window size (L = 32).

Comparison between methods for common values N, M and L Way Need memory Processing power Calculation Complexity BCJR 40,000 words 1/2 40,000 Status Update Sliding window 0 word 1/32 1,280,000 Status Updates Viterbi Sliding Windows 256 words 1/2 80,000 Status Updates The present invention 1132 word 1/2 80,000 Status Updates

As shown in Table 2, the memory requirements of the present invention are within a very reasonable range and much smaller than the BCJR method, while only requiring twice the status update (performing two full reverse returns by default). In contrast, the sliding window method requires less memory, but is not optimal. The block length L can be selected to minimize memory utilization while being independent of the limit length and maintaining optimal performance. In some cases, the memory required by the present invention is less than that required by the Viterbi sliding window method.

The present invention improves processing power and significantly reduces memory than is needed for a turbo decoder, but only slightly increases in complexity. For turbo codes within the 3GPP standard, the intermediate storage of 40960 words can be easily reduced to about 1500 words or less. In contrast, the prior art sliding window technology not only degrades performance, but also requires 10 to 15 times more computational complexity than the present invention.

Although specific components and functions of the soft output decoder for convolutional codes have been described above, those skilled in the art may use fewer or additional functions within the broad scope of the present invention. The invention is not limited by the appended patent claims.

Claims (9)

A method 200 for optimally decoding a received convolutionally coded sequence of signals represented by trellis of block length N, a) dividing the trellis into windows (202); b) selecting (206) a window of length L of said trellis; c) decode a portion of the trellis using backward recursion back to the end of the window from point N at the end of the block to store determined state metrics at the end of each window Step 204; d) decoding a portion of the trellis in the window using a backward return to the beginning of the window, from the known state at the end of the window defined in step c), to Defining a set of known backward recursion state metrics and storing the known set of backward recursion state metrics in memory (208); e) decoding (210) a portion of said trellis within said window using a forward return moving forward starting from a known state at the beginning of said window; And f) calculating a soft output at each stage of the forward return and outputting this soft output at each stage using a forward return state metric, a branch metric and the stored back return state metric Decoding method comprising a. 2. The decoding method according to claim 1, wherein said dividing step (202) comprises making said length L a multiple of the constraint length of said convolutional code. 2. The method of claim 1, wherein said dividing step (202) comprises making said length L independent of a multiple of the constraint length of said convolutional code. The method of claim 1, g) repeating steps b) to f) until the block length N is decoded; Include more, The repeated selecting step includes selecting 206 the next window starting at the end of the currently selected window, Wherein said repeated steps b) to e) are performed concurrently with the current steps c) to f), respectively. A convolution coded signal sequence represented by a trellis of block length N, divided by a soft-decision output decoder 110, 112, 114, 116 into a window of length L in the frame buffer 108. In a radiotelephone 100 having a receiver 104 and a demodulator 106 for processing The decoder, Memory 114; A backward recursion processor 112; Forward recursion processor 110 and Decoder 116 coupled to the memory 114 Including but not limited to: The backward return processor decodes a portion of the trellis using a backward return to the end of the window, starting from point N at the end of the block, and returns a state metric at the end of each window stored in the memory. Define, The backward return processor then decodes a portion of the trellis within the window using the backward return back to the beginning of the window from the known state at the end of the window and stored in the memory. Define a set of known backward return metrics in The forward return processor decodes a portion of the trellis in the window using forward return moving forward, starting from a known state at the beginning of the window, The forward return processor calculates a soft output at each stage of the forward return using the forward return state metric, a backward return state metric stored in the memory, and a branch metric at each stage. And outputting a soft output for the stage. 6. A radiotelephone as set forth in claim 5, wherein said length L is a multiple of a constraint length of said convolutional code. 6. A radiotelephone as claimed in claim 5, wherein the length L is independent of the constraint length of the convolutional code. 6. The method of claim 5, wherein when the forward return processor 110 operates within the window, the backward return processor 112 returns back to the beginning of the next window from the known state at the end of the next window. Decode a portion of the trellis in the next window to obtain a set of known backward return state metrics at the next window stored in the memory 114 when the memory is cleared by the forward return processor 110. And leave the forward reversion processor (100) available immediately after the current window has been processed to begin decoding the next window. 10. The radiotelephone according to claim 8, wherein the front and rear processors (110, 112) operate in parallel until all windows in the block are decoded.