filter.dsp

基于ADSP的G.729语音编解码程序

/************************************************************************/
/* $$01/10/2000 checked filter module data variables and function       */
/* $$01/16/2001 modified and printed,Author: Jason.wang (zhigang wang)  */
/* $$01/16/2001 Email: [e-mail],  BP: 86+02195950-161452         */
/* $$01/16/2001 This modlue is not optimized! should be test on Emulator*/
/************************************************************************/
.MODULE/SEG=App_PM        Filter;

/************************************************************************/
#include       "ld8a.inc"

{
/************************************************************************
* Function  Convolve:                                                   *
* Perform the convolution between two vectors x[] and h[] and           *
* write the result in the vector y[].                                   *
* All vectors are of length N.                                          *
* $$01/10/2000 only used in encoder                                     *
* Calling Parameters												    *	
*         I1   :  Q12 : impulse response                                *
*         I2   :  input vector                                          *
*         CNTR :  vector size                                           *
* Return Values														    *
*         I0  :  output vector                                          *
* Altered Registers: MR,SR,AR,I0,I1,I2,I3,AX0,MY0                       *	
* Computation Time : 18 cycles										    *	
*************************************************************************/
Convolve:      AX0=I2;
               AR=PASS 0;
			   DO conv_loop UNTIL CE;
			   MR=0;
			   I3=I1;
               I2=AX0;
			   AR=AR+1;
			   CNTR=AR;
			   DO sum_conv UNTIL CE;
			   SR0=DM(I2,M1);
			   MY0=DM(I3,M2);
sum_conv:	   IF NOT MV MR=MR+SR0*MY0(SS);
               IF MV SAT MR;
			   SR=LSHIFT MR0 BY 3(LO);
			   SR=SR OR ASHIFT MR1 BY 3(HI);  /* h is in Q12 and saturation */
			   MODIFY(I1,M1);
conv_loop:	   DM(I0,M1)=SR1;
               RTS;
}
/************************************************************************
* procedure Syn_filt: Do the synthesis filtering 1/A(z).                *
* $$01/10/2000 only used in encoder and decoder                         *
* Calling Parameters												    *	
*         I1    : Q12 : a[m+1] prediction coefficients   (m=10)         *
*         I2    : input signal                                          *
*         SI    : size of filtering                                     *
*         I3    : memory associated with this filtering.                *
*         AY0   : 0=no update, 1=update of memory.                      *
* Return Values														    *
*         I0   : output signal                                          *
*		  AR   : overflow                                               *
* Altered Registers: MR,SR,SE,AR,I0,L0,M0,M1,AY0,MY0                    *	
* Computation Time : 18 cycles										    *	
*************************************************************************/
.ENTRY         Syn_filt;
.VAR/DM/RAM/SEG=App_DMbuf    tmp[100],overflow;

Syn_filt:      AY1=I3;
//			   CNTR=M;
               I4=^tmp;
			   CNTR=M;
               DO copy_syn UNTIL CE;
			   AR=PASS 0,AX1=DM(I3,M1);
copy_syn:	   DM(I4,M4)=AX1;
        /*-----Do the filtering.-------*/
			   DM(overflow)=AR;
			   AX1=I1;
//               CNTR=SI; 
			   AF=PASS 3;  
               CNTR=SI; 
			   DO synth_loop UNTIL CE;
				  I5=I4;
			      I1=AX1;
//			      CNTR=M;
			      MX0=DM(I1,M1);
			      MY0=DM(I2,M1);
			      MR=MX0*MY0(SS),AR=DM(I5,M7);
			      CNTR=M;
				  DO sum_synth UNTIL CE;
			      MX0=DM(I1,M1);
			      MY0=DM(I5,M7);
sum_synth:	      IF NOT MV MR=MR-MX0*MY0(SS);
		          IF MV SAT MR;
        		  SE=EXP MR1(HI);
				  SE=EXP MR0(LO);
				  AR=SE;
				  AR=AR+AF;
				  IF LE JUMP roundsyn;
				  AR=PASS MR1;
				  AR=H#8000;
				  DM(overflow)=AR;
				  IF GE AR=PASS H#7FFF;
				  JUMP synth_loop;
roundsyn:         SR=LSHIFT MR0 BY 3(LO);
				  SR=SR OR ASHIFT MR1 BY 3(HI);
				  AR=SR0+H#8000;
				  AR=SR1+C;		      
synth_loop:	   DM(I4,M4)=AR;
			   I4=^tmp+M;
               CNTR=SI;
			   DO copy_filter UNTIL CE;
			   AR=DM(I4,M4);
copy_filter:   DM(I0,M1)=AR;
     /*--------Update of memory if update==1---------*/
			   AR=DM(overflow);
               NONE=PASS AY0;
			   IF EQ RTS;
			   M3=-M;
			   I3=AY1;
//			   CNTR=M;
			   MODIFY(I0,M3);
			   CNTR=M;
			   DO copy_result UNTIL CE;
			   AY0=DM(I0,M1);
copy_result:   DM(I3,M1)=AY0;
		       RTS;
/************************************************************************
* Compute the LPC residual by filtering the input speech through A(z)   *
* Calling Parameters												    *	
* $$01/10/2000 used both in encoder and decoder                         *
*         I2    : Q12 : prediction coefficients                         *
*         I1    : speech (values x[-m..-1] are needed                   *
*         CNTR  : size of filtering                                     *
* Return Values														    *
*         I0    : residual signal                                       *
* Altered Registers: MR,SR,AR,I0,I1,I2,I3,AX0,MY0                       *	
* Computation Time : 18 cycles										    *	
*************************************************************************/
.ENTRY         Residu;

Residu:        AX0=I2;
			   AF=PASS 3;
			   DO residu_loop UNTIL CE;
			      I2=AX0;
			      I3=I1; 
//			      CNTR=M;
			      MX0=DM(I3,M2);
			      MY0=DM(I2,M1);
			      MR=MX0 * MY0(SS);
			      CNTR=M;
			      DO residu_sum UNTIL CE;
			      SR0=DM(I2,M1);
			      MY0=DM(I3,M2);
residu_sum:       IF NOT MV MR=MR+SR0*MY0(SS);
 	              IF MV SAT MR;
        		  SE=EXP MR1(HI);
				  SE=EXP MR0(LO),AR=DM(I1,M1);
				  AR=SE;
				  AR=AR+AF;
				  IF LE JUMP round_residu;
				  AR=PASS MR1;
				  AR=H#8000;
				  IF GE AR=PASS H#7FFF;
				  JUMP residu_loop;
round_residu:     SR=LSHIFT MR0 BY 3(LO);
				  SR=SR OR ASHIFT MR1 BY 3(HI);
				  AR=SR0+H#8000;
				  AR=SR1+C;		      
residu_loop:   DM(I0,M1)=AR;
               RTS;
/************************************************************************/
.ENDMOD;