dpll.asm

用dsp解压mp3程序的算法

*
*  Initialize ARs as address pointers
*
        LAR     AR1,#en_in     ; AR1 -> e(n) input data buffer
        LAR     AR3,#cn_out    ; AR3 -> c(n) output dtat buffer
                               ; AR7 used for MISC

        EINT                   ; enable interrupts
*
***************************************************************************
*    Start of main program
***************************************************************************
*  Processing of REF 1 signal
*
MAIN:   LDP     #4            ; DP = 4, page 4
        MAR     *,AR7         ; ARP = 7
*
*  e(n)  ----------------- e'(n)
*  ----->| Median filter |------>
*        -----------------
*
*  Update median filter buffer

        LAR     AR7,#med1_buf3 ; AR7 -> med_buf[3]
        RPT     #3             ; repeat next instruction 4 times
        DMOV    *-             ; med_buf[i+1] <= med_buf[i],i=3,2,1,0
        MAR     *,AR1          ; ARP = 1
        LACL    *+,AR7         ; ACCL <= e(n), ARP = 7, AR1+1 thus
                               ; AR1 points to next e(n)
        LAR     AR7,#med1_buf0 ; AR7 -> med_buf[0]
        SACL    *              ; med_buf[0] <= e(n), new input data

*  Move data from median filter buffer to sorting buffer

        BLDD    *+,#sort1_buf0 ; sort_buf[0] <= med_buf[0]
        BLDD    *+,#sort1_buf1 ; sort_buf[1] <= med_buf[1]
        BLDD    *+,#sort1_buf2 ; sort_buf[2] <= med_buf[2]
        BLDD    *+,#sort1_buf3 ; sort_buf[3] <= med_buf[3]
        BLDD    *+,#sort1_buf4 ; sort_buf[4] <= med_buf[4]

*
*  Sorting data in sort_buf of size 5
*    A. sort_buf[0] <- largest sample
*    B. sort_buf[1] <- second largest sample
*    C. sort_buf[2] <- median sample, output of median filter
*

*  A. Find largest sample, put into sort_buf[0]

                              ; comparing sort_buf[0] with sort_buf[1]
        LACL    sort1_buf0    ; ACC <= sort_buf[0]
        SUB     sort1_buf1    ; compare with sort_buf[1]
        BCND    NEXT1_A2,GEQ  ; branch to NEXT1_A2 if sort_buf[0] is larger

*  Swap sort_buf[0] with sort_buf[1] if sort_buf[1] is larger

        LACL    sort1_buf0    ; ACC <= sort_buf[0]
        SACL    temp1         ; temp1 <= sort_buf[0]
        LACL    sort1_buf1    ; ACC <= sort_buf[1]
        SACL    sort1_buf0    ; sort_buf[0] <= sort_buf[1]
        LACL    temp1         ; ACC <= old sort_buf[0]
        SACL    sort1_buf1    ; sort_buf[1] <= old sort_buf[0]

NEXT1_A2:                     ; comparing sort_buf[0] with sort_buf[2]
        LACL    sort1_buf0    ; ACC <= sort_buf[0]
        SUB     sort1_buf2    ; compare with sort_buf[2]
        BCND    NEXT1_A3,GEQ  ; branch to NEXT1_A3 if sort_buf[0] is larger

*  Swap sort_buf[0] with sort_buf[2] if sort_buf[2] is larger

        LACL    sort1_buf0    ; ACC <= sort_buf[0]
        SACL    temp1         ; temp1 <= sort_buf[0]
        LACL    sort1_buf2    ; ACC <= sort_buf[2]
        SACL    sort1_buf0    ; sort_buf[0] <= sort_buf[2]
        LACL    temp1         ; ACC <= old sort_buf[0]
        SACL    sort1_buf2    ; sort_buf[2] <= old sort_buf[0]

NEXT1_A3:                     ; comparing sort_buf[0] with sort_buf[3]
        LACL    sort1_buf0    ; ACC <= sort_buf[0]
        SUB     sort1_buf3    ; compare with sort_buf[3]
        BCND    NEXT1_A4,GEQ  ; branch to NEXT1_A4 if sort_buf[0] is larger

*  Swap sort_buf[0] with sort_buf[3] if sort_buf[3] is larger

        LACL    sort1_buf0    ; ACC <= sort_buf[0]
        SACL    temp1         ; temp1 <= sort_buf[0]
        LACL    sort1_buf3    ; ACC <= sort_buf[3]
        SACL    sort1_buf0    ; sort_buf[0] <= sort_buf[3]
        LACL    temp1         ; ACC <= old sort_buf[0]
        SACL    sort1_buf3    ; sort_buf[3] <= old sort_buf[0]

NEXT1_A4:                     ; comparing sort_buf[0] with sort_buf[4]
        LACL    sort1_buf0    ; ACC <= sort_buf[0]
        SUB     sort1_buf4    ; compare with sort_buf[4]
        BCND    NEXT1_B2,GEQ  ; branch to NEXT1_B2 if sort_buf[0] is larger

*  Swap sort_buf[0] with sort_buf[4] if sort_buf[4] is larger

        LACL    sort1_buf0    ; ACC <= sort_buf[0]
        SACL    temp1         ; temp1 <= sort_buf[0]
        LACL    sort1_buf4    ; ACC <= sort_buf[4]
        SACL    sort1_buf0    ; sort_buf[0] <= sort_buf[4]
        LACL    temp1         ; ACC <= old sort_buf[0]
        SACL    sort1_buf4    ; sort_buf[4] <= old sort_buf[0]

*  B. Find the second largest sample, put into sort_buf[1]

NEXT1_B2:                     ; comparing sort_buf[1] with sort_buf[2]
        LACL    sort1_buf1    ; ACC <= sort_buf[1]
        SUB     sort1_buf2    ; compare with sort_buf[2]
        BCND    NEXT1_B3,GEQ  ; branch to NEXT1_B3 if sort_buf[1] is larger

*  Swap sort_buf[1] with sort_buf[2] if sort_buf[2] is larger

        LACL    sort1_buf1    ; ACC <= sort_buf[1]
        SACL    temp1         ; temp1 <= sort_buf[1]
        LACL    sort1_buf2    ; ACC <= sort_buf[2]
        SACL    sort1_buf1    ; sort_buf[1] <= sort_buf[2]
        LACL    temp1         ; ACC <= old sort_buf[1]
        SACL    sort1_buf2    ; sort_buf[2] <= old sort_buf[1]

NEXT1_B3:                     ; comparing sort_buf[1] with sort_buf[3]
        LACL    sort1_buf1    ; ACC <= sort_buf[1]
        SUB     sort1_buf3    ; compare with sort_buf[3]
        BCND    NEXT1_B4,GEQ  ; branch to NEXT1_B4 if sort_buf[1] is larger

*  Swap sort_buf[1] with sort_buf[3] if sort_buf[3] is larger

        LACL    sort1_buf1    ; ACC <= sort_buf[1]
        SACL    temp1         ; temp1 <= sort_buf[1]
        LACL    sort1_buf3    ; ACC <= sort_buf[3]
        SACL    sort1_buf1    ; sort_buf[1] <= sort_buf[3]
        LACL    temp1         ; ACC <= old sort_buf[1]
        SACL    sort1_buf3    ; sort_buf[3] <= old sort_buf[1]

NEXT1_B4:                     ; comparing sort_buf[1] with sort_buf[4]
        LACL    sort1_buf1    ; ACC <= sort_buf[1]
        SUB     sort1_buf4    ; compare with sort_buf[4]
        BCND    NEXT1_C3,GEQ  ; branch to NEXT1_C3 if sort_buf[1] is larger

*  Swap sort_buf[1] with sort_buf[4] if sort_buf[4] is larger

        LACL    sort1_buf1    ; ACC <= sort_buf[1]
        SACL    temp1         ; temp1 <= sort_buf[1]
        LACL    sort1_buf4    ; ACC <= sort_buf[4]
        SACL    sort1_buf1    ; sort_buf[1] <= sort_buf[4]
        LACL    temp1         ; ACC <= old sort_buf[1]
        SACL    sort1_buf4    ; sort_buf[4] <= old sort_buf[1]

*  C. Find the median sample, put into sort_buf[2]

NEXT1_C3:                     ; comparing sort_buf[2] with sort_buf[3]
        LACL    sort1_buf2    ; ACC <= sort_buf[2]
        SUB     sort1_buf3    ; compare with sort_buf[3]
        BCND    NEXT1_C4,GEQ  ; branch to NEXT1_C4 if sort_buf[2] is larger

*  Swap sort_buf[2] with sort_buf[3] if sort_buf[3] is larger

        LACL    sort1_buf2    ; ACC <= sort_buf[2]
        SACL    temp1         ; temp1 <= sort_buf[2]
        LACL    sort1_buf3    ; ACC <= sort_buf[3]
        SACL    sort1_buf2    ; sort_buf[1] <= sort_buf[3]
        LACL    temp1         ; ACC <= old sort_buf[2]
        SACL    sort1_buf3    ; sort_buf[3] <= old sort_buf[2]

NEXT1_C4:                     ; comparing sort_buf[2] with sort_buf[4]
        LACL    sort1_buf2    ; ACC <= sort_buf[2]
        SUB     sort1_buf4    ; compare with sort_buf[4]
        BCND    LPF,GEQ       ; branch to LPF if sort_buf[2] is larger

*  sort_buf[2] <= sort_buf[4] if sort_buf[4] is larger

        LACL    sort1_buf4    ; ACC <= sort_buf[4]
        SACL    sort1_buf2    ; sort_buf[2] <= sort_buf[4]

*
*  Sorting is completed, sort_buf[2] contains median filter output e'(n)
*
*  LPF is implemented as 1st-order IIR filter approximation of
*    moving-average filter of order L
* 
*    e'(n)  -------  c(n)
*    ------>| LPF |----->
*           -------
*
*    c(n) = (1-a)*c(n-1) + a*e'(n)
*         = c(n-1) - a*c(n-1) + a*e'(n)
*    where
*         a = 1/L. Assume L = 2^m, 
*         a = 2^-m, which can be implemented by shifting right m bits
*  Assume L = 256 is used for LPF here

LPF:    LACC    cn_high,16    ; ACCH <= c(n-1), high word
        ADDS    cn_low        ; ACC = c(n-1)
        SUB     cn_high,m8    ; - a*c(n-1)
        ADD     sort1_buf2,m8 ; + a*e'(n)
        SACH    cn_high       ; save c(n), high word
        SACL    cn_low        ; save c(n), low word

        LAR     AR7,#cn       ; AR7 -> address of c(n) at page 0
        ADD     #1,15         ; rounding
        SACH    *             ; move to page 0, AR7 -> address of c(n)
        MAR     *,AR3         ; ARP = 3
        SACH    *+            ; save c(n) to memory locations
                              ; pointed by AR3, cn_out

* Following code is used for CCS simulation only 

        LACL    loop_cnt      ; ACC <= loop counter
        ADD     ONE           ; ACC + 1
        SACL    loop_cnt      ; loop counter incremented by 1

OUTPUT: 
        LACL    loop_cnt      ; ACC <= loop counter
        SUB     #file_length  ; end of loop?
        BCND    FOREVER,EQ    ; end of loop, branch to FOREVER
        B       MAIN          ; branch to MAIN for next iteration
FOREVER: B      FOREVER       ; end of loop, loop forever here
        .end