Name: LATFIR1.ASM Type: Assembler Macro Version: 1.0 Last Change: 8-Aug-86 Description: Lattice FIR Filter Assembler Macro This macro implements a lattice fir filter using reflection coefficients. BACKGROUND The basic section of a FIR lattice filter is shown in Figure 1. >-------------------------------(+)-----------> f[j-1](n) \ ^ f[j](n) \ / \ k[j] \ / / / k[j] / \ / v >------1/z----------------------(+)-----------> b[j-1](n) b[j-1](n-1) b[j](n) Figure 1 The reference [j] indicates the jth stage and the reference (n) indicates the sample time. The equations for a filter section are: f[j](n)= f[j-1](n) + k[j]*b[j-1](n-1) b[j](n)= b[j-1](n-1) + k[j]*f[j-1](n) The signals f(n) and b(n) are commonly referred to as the forward and backward prediction residuals respectively. IMPLEMENTATION A third order lattice FIR filter is shown in Figure 2. T |--->----->---(+)-->----->----(+)-->----->----(+)----> B (out) | | ^ | ^ | ^ | | / | / | / | \ k1 \ k2 \ k3 ^ \ / \ / \ / | / / / B >--| /\ /\ /\ (in) | / \ / \ / \ v / k1 / k2 / k3 | | \ | \ | \ | | v | v | v |- 1/z ---->--(+)- 1/z ---->--(+)- 1/z ---->--(+)----- S1 S2 S3 Sx Figure 2 For the filter shown, the pointers R0 and R4 are initialized to point to the buffers as shown: R0 R4 | | v v x: S1 S2 S3 Sx y: k1 k2 k3 kx M0=3 (mod 4) M4=3 (mod 4) The register R0 is initialized to point to the start of the state variable buffer and R4 is initialized to point to the first k coefficient of the filter. The modulo registers are set to the number of coefficients in the filter (in this example there are three). Note that the modulo storage area is equal to the number of filter coefficients+1. The input sample is put in the B register and then the filter macro is called. The result of the filtering operation is in B. The state 'sx' is an unused state which aids calculation efficiency. (Actually, the value sx after a sample is filtered is the output of the lower leg of the filter.) The reflection coefficient 'kx' is an unused dummy value. To use the filter, it is assumed the registers R0, R4, M0 and M4 have been properly initialized. The input sample is put in register B and the filter is called as: latfir order ;call fir lattice filter where 'latfir' is the macro name and 'order' is the number of k coefficients. FILTER OPERATION The filter operation can be described (refer to Figure 2 and the macro 'latfir1' in the DSPLIB): 1. The input sample is in register B. This input sample will be the first state S1 at the next sample time and will initialize the T value. 2. The first MOVE instruction saves the input sample to be the first state S1 for the next sample and increments the pointer R0 to the next state. The first k coefficient k1 is loaded into y0 and the pointer R4 is incremented to point to the next coefficient. 3. The loop will make as many passes of the filter kernel as there are coefficients in the filter. 4. The old state S1 is loaded into accumulator A so that the the bottom b[j](n) can be computed (see Figure 1). The current value of T (in register B) is moved into a product register so it can be multiplied by the k coefficient. 5. The value b[j](n) is now computed by the first MAC. The T value in Y1 is multiplied by the k coefficient in Y0 and added to the value of the previous state (A). This value will be the value of S2 for the next sample time. The value in register A (the state value) is simultaneously copied into product register X0 so it can be multiplied by k in the next instruction. 6. The state (X0) is now multiplied by the k coefficient (Y0) and added to the old value of T to get the new value of T. Simultaneously, the new state variable (A) is saved and the next k coefficient is obtained. The pointers R0 and R4 are both incremented to point to the next state and coefficient respectively. 7. Three passes of this loop are made. The first state needed for the second sample is currently saved at the first location of the state buffer with the other states calculated by the loop saved in consecutive locations. The last state that the loop calculates (Sx) is not needed for the next sample time. 8. The result is rounded and the pointer to the state buffer is backed up by one. This points the state buffer to the unused state (Sx) so that the next sample is saved over the unused state. Note that the initial MOVE increments the pointer to the k's by one and the loop increments the pointer three times. In order to have the pointer to the k's pointing to the first coefficient (k1), the modulo on the k pointer is four. The benchmarks for this filter are: 7 instructions, 3N+5 instruction cycles, 2 stack locations. An example of how to use this macro is in the DSPLIB in the file LATFIR1T.ASM.