gsm.c

vc环境下的pgp源码

    muls.w d3,d4
    addi.l #16384,d4
    asr.l d5,d4
    
    //di = GSM_ADD( di, GSM_MULT_R(*rpi++, ui))
    add.w d4,d1
    bvc @endadd16
    bmi @pos16
    move.w #-32768,d1
    bra @endadd16
@pos16:
    move.w #32767, d1
@endadd16:

    // *s = di;
    move.w d1,(a2)+

    subq.w #1,d0
    bne @loop

    movem.l (a7)+,d3-d5/a2-a4
    frfree
    rts
}

#else	/*	__MC68K__	*/
static void Short_term_analysis_filtering(
        register word   *u,
        register word   * rp,   /* [0..7]       IN      */
        register int    k_n,    /*   k_end - k_start    */
        register word   * s     /* [0..n-1]     IN/OUT  */
)
/*
 *  This procedure computes the short term residual signal d[..] to be fed
 *  to the RPE-LTP loop from the s[..] signal and from the local rp[..]
 *  array (quantized reflection coefficients).  As the call of this
 *  procedure can be done in many ways (see the interpolation of the LAR
 *  coefficient), it is assumed that the computation begins with index
 *  k_start (for arrays d[..] and s[..]) and stops with index k_end
 *  (k_start and k_end are defined in 4.2.9.1).  This procedure also
 *  needs to keep the array u[0..7] in memory for each call.
 */
{
        word           di, sav, *rpi, *uii, ui;
        for (; k_n--; s++) {
          di = sav = *s;
          rpi = rp;
          uii = u;
#define ST_ANAL_INSIDE \
  ui = *uii; *uii++ = sav; \
  sav = GSM_ADD( ui, GSM_MULT_R(*rpi, di)); \
  di = GSM_ADD( di, GSM_MULT_R(*rpi++, ui));
          ST_ANAL_INSIDE       /* 0 */
          ST_ANAL_INSIDE       /* 1 */
          ST_ANAL_INSIDE       /* 2 */
          ST_ANAL_INSIDE       /* 3 */
          ST_ANAL_INSIDE       /* 4 */
          ST_ANAL_INSIDE       /* 5 */
          ST_ANAL_INSIDE       /* 6 */
          ST_ANAL_INSIDE       /* 7 */
          *s = di;
        }
}
#endif	/*	__MC68K__	*/


#ifdef __MC68K__
static asm void Short_term_synthesis_filtering(
        word   *v,
        word   * rrp,  /* [0..7]       IN      */
        int    k,      /* k_end - k_start      */
        word   * wt,   /* [0..k-1]     IN      */
        word   * srr    /* [0..k-1]     OUT     */
)
{
        fralloc+
        /*
         * 68K assembler version, with the internal loop unrolled and all the adds
         * and multiplies inlined. All variables are placed in registers. The 
         * multiplies in these routines need to check for MIN_WORD * MIN_WORD.
         *
         * Registers used, in terms of variables in the C version:
         *
         * a0: &v[i] -- decremented in unrolled loop
         * a1: &rrp[i] -- decremented in unrolled loop
         * a2: &v[i+1] -- decremented in unrolled loop
         * a3: wt
         * a4: srr (note: this is renamed from the C variable "sr")
         *
         * d0: k
         * d1: sri
         * d2: scratch register
         * d3: scratch register
         * d4: 15 -- number of bits to right shift in the GSM_MULT_R routine
         *
         * d5-d7 are used as storage for the values used to initialize a0-a3 at the
         * head of the unrolled loop:
         *
         * d5: v + 14: pointer to v[i] at the start of the unrolled loop
         * d6: v + 16: pointer to v[i+1] at the start of the unrolled loop
         * d7: rrp + 14: pointer to rrp[i] at the start of the unrolled loop
         *
         */
        movem.l d3-d7/a2-a4,-(a7)
        move.w k,d0
        movea.l wt,a3
        movea.l srr,a4
        moveq #15,d4            // d4 contains the size of the shift for GSM_MULT_R
        
        move.l v,d5                     // Put the starting loop addresses into spare data registers
        move.l d5,d6
        addi.l #14,d5
        addi.l #16,d6
        move.l rrp,d7
        addi.l #14,d7

@loop:
        move.w (a3)+,d1         // sri = *wt++
        
// Set up the address registers for the unrolled loop
        movea.l d5,a0           // a0 = &v[i]
        movea.l d7,a1           // a1 = &rrp[i]
        movea.l d6,a2           // a2 = &v[i+1]
        
// Now do the loop for i = 7 to 0
// i = 7
        //GSM_MULT_R( rrp[i], v[i] )
        move.w (a1),d2                          // d2,d3 are scratch registers
        move.w (a0),d3
        muls.w d2,d3                            // multiply
        addi.l #16384,d3                        // round
        asr.l d4,d3                                     // right shift 15
        cmpi.w #0x8000,d3                       // check for MIN_WORD * MIN_WORD
        bne @endmult71
        move.w #0x7FFF,d3                       // MIN_WORD * MIN_WORD = MAX_WORD
@endmult71:
        
        //sri = GSM_SUB( sri, GSM_MULT_R( rrp[i], v[i] ) )
        sub.w d3,d1                                     // sri is in d1
        bvc @endsub7
        bmi @possub7
        move.w #-32768,d1                       // negative overflow
        bra @endsub7
@possub7:
        move.w #32767, d1                       // positive overflow
@endsub7:
        
        //GSM_MULT_R( rrp[i], sri )
        muls.w d1,d2                            // multiply (d2 still has rrp[i] in it)
        addi.l #16384,d2                        // round
        asr.l d4,d2                                     // right shift 15
        cmpi.w #0x8000,d2                       // check for MIN_WORD * MIN_WORD
        bne @endmult72
        move.w #0x7FFF,d2                       // MIN_WORD * MIN_WORD = MAX_WORD
@endmult72:
        
        //v[i+1] = GSM_ADD( v[i], GSM_MULT_R( rrp[i], sri ) )
        move.w (a0),d3                          // annoying to have to do this twice...
        add.w d2,d3                                     // add
        bvc @endadd7
        bmi @posadd7
        move.w #-32768,d3                       // negative overflow
        bra @endadd7
@posadd7:
        move.w #32767, d3                       // positive overflow
@endadd7:
        move.w d3,(a2)                          // move result to v[i+1]
        
// i = 6
        //GSM_MULT_R( rrp[i], v[i] )
        move.w -(a1),d2                         // d2,d3 are scratch registers
        move.w -(a0),d3
        muls.w d2,d3
        addi.l #16384,d3
        asr.l d4,d3
        cmpi.w #0x8000,d3
        bne @endmult61
        move.w #0x7FFF,d3
@endmult61:
        
        //sri = GSM_SUB( sri, GSM_MULT_R( rrp[i], v[i] ) )
        sub.w d3,d1
        bvc @endsub6
        bmi @possub6
        move.w #-32768,d1
        bra @endsub6
@possub6:
        move.w #32767, d1
@endsub6:
        
        //GSM_MULT_R( rrp[i], sri )
        muls.w d1,d2                                    // d2 still has rrp[i] in it
        addi.l #16384,d2
        asr.l d4,d2
        cmpi.w #0x8000,d2
        bne @endmult62
        move.w #0x7FFF,d2
@endmult62:
        
        //v[i+1] = GSM_ADD( v[i], GSM_MULT_R( rrp[i], sri ) )
        move.w (a0),d3
        add.w d2,d3
        bvc @endadd6
        bmi @posadd6
        move.w #-32768,d3
        bra @endadd6
@posadd6:
        move.w #32767, d3
@endadd6:
        move.w d3,-(a2)
        
// i = 5
        //GSM_MULT_R( rrp[i], v[i] )
        move.w -(a1),d2                         // d2,d3 are scratch registers
        move.w -(a0),d3
        muls.w d2,d3
        addi.l #16384,d3
        asr.l d4,d3
        cmpi.w #0x8000,d3
        bne @endmult51
        move.w #0x7FFF,d3
@endmult51:
        
        //sri = GSM_SUB( sri, GSM_MULT_R( rrp[i], v[i] ) )
        sub.w d3,d1
        bvc @endsub5
        bmi @possub5
        move.w #-32768,d1
        bra @endsub5
@possub5:
        move.w #32767, d1
@endsub5:
        
        //GSM_MULT_R( rrp[i], sri )
        muls.w d1,d2                                    // d2 still has rrp[i] in it
        addi.l #16384,d2
        asr.l d4,d2
        cmpi.w #0x8000,d2
        bne @endmult52
        move.w #0x7FFF,d2
@endmult52:
        
        //v[i+1] = GSM_ADD( v[i], GSM_MULT_R( rrp[i], sri ) )
        move.w (a0),d3
        add.w d2,d3
        bvc @endadd5
        bmi @posadd5
        move.w #-32768,d3
        bra @endadd5
@posadd5:
        move.w #32767, d3
@endadd5:
        move.w d3,-(a2)

// i = 4
        //GSM_MULT_R( rrp[i], v[i] )
        move.w -(a1),d2                         // d2,d3 are scratch registers
        move.w -(a0),d3
        muls.w d2,d3
        addi.l #16384,d3
        asr.l d4,d3
        cmpi.w #0x8000,d3
        bne @endmult41
        move.w #0x7FFF,d3
@endmult41:
        
        //sri = GSM_SUB( sri, GSM_MULT_R( rrp[i], v[i] ) )
        sub.w d3,d1
        bvc @endsub4
        bmi @possub4
        move.w #-32768,d1
        bra @endsub4
@possub4:
        move.w #32767, d1
@endsub4:
        
        //GSM_MULT_R( rrp[i], sri )
        muls.w d1,d2                                    // d2 still has rrp[i] in it
        addi.l #16384,d2
        asr.l d4,d2
        cmpi.w #0x8000,d2
        bne @endmult42
        move.w #0x7FFF,d2
@endmult42:
        
        //v[i+1] = GSM_ADD( v[i], GSM_MULT_R( rrp[i], sri ) )
        move.w (a0),d3
        add.w d2,d3
        bvc @endadd4
        bmi @posadd4
        move.w #-32768,d3
        bra @endadd4
@posadd4:
        move.w #32767, d3
@endadd4:
        move.w d3,-(a2)

// i = 3
        //GSM_MULT_R( rrp[i], v[i] )
        move.w -(a1),d2                         // d2,d3 are scratch registers
        move.w -(a0),d3
        muls.w d2,d3
        addi.l #16384,d3
        asr.l d4,d3
        cmpi.w #0x8000,d3
        bne @endmult31
        move.w #0x7FFF,d3
@endmult31:
        
        //sri = GSM_SUB( sri, GSM_MULT_R( rrp[i], v[i] ) )
        sub.w d3,d1
        bvc @endsub3
        bmi @possub3
        move.w #-32768,d1
        bra @endsub3
@possub3:
        move.w #32767, d1
@endsub3:
        
        //GSM_MULT_R( rrp[i], sri )
        muls.w d1,d2                                    // d2 still has rrp[i] in it
        addi.l #16384,d2
        asr.l d4,d2
        cmpi.w #0x8000,d2
        bne @endmult32
        move.w #0x7FFF,d2
@endmult32:
        
        //v[i+1] = GSM_ADD( v[i], GSM_MULT_R( rrp[i], sri ) )
        move.w (a0),d3
        add.w d2,d3
        bvc @endadd3
        bmi @posadd3
        move.w #-32768,d3
        bra @endadd3
@posadd3:
        move.w #32767, d3
@endadd3:
        move.w d3,-(a2)

// i = 2
        //GSM_MULT_R( rrp[i], v[i] )
        move.w -(a1),d2                         // d2,d3 are scratch registers
        move.w -(a0),d3
        muls.w d2,d3
        addi.l #16384,d3
        asr.l d4,d3
        cmpi.w #0x8000,d3
        bne @endmult21
        move.w #0x7FFF,d3
@endmult21:
        
        //sri = GSM_SUB( sri, GSM_MULT_R( rrp[i], v[i] ) )
        sub.w d3,d1
        bvc @endsub2
        bmi @possub2
        move.w #-32768,d1
        bra @endsub2
@possub2:
        move.w #32767, d1
@endsub2:
        
        //GSM_MULT_R( rrp[i], sri )
        muls.w d1,d2                                    // d2 still has rrp[i] in it
        addi.l #16384,d2
        asr.l d4,d2
        cmpi.w #0x8000,d2
        bne @endmult22
        move.w #0x7FFF,d2
@endmult22:
        
        //v[i+1] = GSM_ADD( v[i], GSM_MULT_R( rrp[i], sri ) )
        move.w (a0),d3
        add.w d2,d3
        bvc @endadd2
        bmi @posadd2
        move.w #-32768,d3
        bra @endadd2
@posadd2:
        move.w #32767, d3
@endadd2:
        move.w d3,-(a2)

// i = 1
        //GSM_MULT_R( rrp[i], v[i] )
        move.w -(a1),d2                         // d2,d3 are scratch registers
        move.w -(a0),d3
        muls.w d2,d3
        addi.l #16384,d3
        asr.l d4,d3
        cmpi.w #0x8000,d3
        bne @endmult11
        move.w #0x7FFF,d3
@endmult11:
        
        //sri = GSM_SUB( sri, GSM_MULT_R( rrp[i], v[i] ) )
        sub.w d3,d1
        bvc @endsub1
        bmi @possub1
        move.w #-32768,d1
        bra @endsub1
@possub1:
        move.w #32767, d1
@endsub1:
        
        //GSM_MULT_R( rrp[i], sri )
        muls.w d1,d2                                    // d2 still has rrp[i] in it
        addi.l #16384,d2
        asr.l d4,d2
        cmpi.w #0x8000,d2
        bne @endmult12
        move.w #0x7FFF,d2
@endmult12:
        
        //v[i+1] = GSM_ADD( v[i], GSM_MULT_R( rrp[i], sri ) )
        move.w (a0),d3
        add.w d2,d3
        bvc @endadd1
        bmi @posadd1
        move.w #-32768,d3
        bra @endadd1
@posadd1:
        move.w #32767, d3
@endadd1:
        move.w d3,-(a2)

// i = 0
        //GSM_MULT_R( rrp[i], v[i] )
        move.w -(a1),d2                         // d2,d3 are scratch registers
        move.w -(a0),d3
        muls.w d2,d3
        addi.l #16384,d3
        asr.l d4,d3
        cmpi.w #0x8000,d3
        bne @endmult01
        move.w #0x7FFF,d3
@endmult01:
        
        //sri = GSM_SUB( sri, GSM_MULT_R( rrp[i], v[i] ) )
        sub.w d3,d1
        bvc @endsub0
        bmi @possub0
        move.w #-32768,d1
        bra @endsub0
@possub0:
        move.w #32767, d1
@endsub0:
        
        //GSM_MULT_R( rrp[i], sri )
        muls.w d1,d2                                    // d2 still has rrp[i] in it
        addi.l #16384,d2
        asr.l d4,d2
        cmpi.w #0x8000,d2
        bne @endmult02
        move.w #0x7FFF,d2
@endmult02:
        
        //v[i+1] = GSM_ADD( v[i], GSM_MULT_R( rrp[i], sri ) )
        move.w (a0),d3
        add.w d2,d3
        bvc @endadd0
        bmi @posadd0
        move.w #-32768,d3
        bra @endadd0
@posadd0:
        move.w #32767, d3
@endadd0: