www.pudn.com > AVS_M_ver10.rar > perceptual.c
/*
***********************************************************************
* COPYRIGHT AND WARRANTY INFORMATION
*
* Copyright 2007 Audio Video Coding Standard, Part ¢ú
*
* This software module was developed by AVS Audio sub-group
*
* DISCLAIMER OF WARRANTY
*
* These software programs are available to the users without any
* license fee or royalty on an "as is" basis. The AVS disclaims
* any and all warranties, whether express, implied, or statutory,
* including any implied warranties of merchantability or of fitness
* for a particular purpose. In no event shall the contributors or
* the AVS be liable for any incidental, punitive, or consequential
* damages of any kind whatsoever arising from the use of this program.
*
* This disclaimer of warranty extends to the user of this program
* and user's customers, employees, agents, transferees, successors,
* and assigns.
*
* The AVS does not represent or warrant that the program furnished
* hereunder are free of infringement of any third-party patents.
* Commercial implementations of AVS, including shareware, may be
* subject to royalty fees to patent holders. Information regarding
* the AVS patent policy is available from the AVS Web site at
* http://www.avs.org.cn
*
* THIS IS NOT A GRANT OF PATENT RIGHTS - SEE THE AVS PATENT POLICY.
************************************************************************
*/
#include "../include/perceptual.h"
/************************************************************************/
/* implement: 1/P(z/gamma)
that is:y(n)=x(n)-E(ai*gamma(i)*x(n-i)) */
/************************************************************************/
void E_UTIL_formant(Float32 *signal, Float32 *a, Word32 L, Float32 *mem)
{
int i,j;
int k;
Float32 temp;
for(i=0;i0 && j<=M)
{
temp-=a[j++]*signal[--k];
}
k=0;
while(j<=M)
{
temp-=a[j++]*mem[(M-1)-(k++)];
}
signal[i]=temp;
}
//update the memory
for(i=0;i -1e-10))
{
mem[M-1-i] =0.0;
}
}
return;
}
/************************************************************************/
/* the inverse procedure of E_UTIL_formant */
/************************************************************************/
void E_UTIL_deformant(Float32 *signal, Float32 *a, Word32 L, Float32 *mem)
{
int i,j,k;
Float32 temp[M];
//remember the memory
for(i=0;i=M;i--)
{
for(j=1;j<=M;j++)
{
signal[i]+=a[j]*signal[i-j];
}
}
//using the memory partly
for(i=M-1;i>=0;i--)
{
j=1;
while( (i-j)>=0 )
{
signal[i]+=a[j]*signal[i-j];
j++;
}
k=M-1;
while(j<=M)
{
signal[i]+=a[j]*mem[k];
j++;
k--;
}
}
//update the memory
for(i=0;i -1e-10))
{
mem[i] =0.0;
}
}
return;
}
/************************************************************************/
/*implement the tilt computation
that is:y(n)=x(n)+E(ai*gamma(i)*y) */
/************************************************************************/
void E_UTIL_tilt(Float32 *signal, Float32 *a, Word32 L, Float32 *mem)
{
Word32 i,j,k;
Float32 temp[TILT_ORDER];
for(i=0;i=TILT_ORDER;i--)
{
for(j=1;j<=TILT_ORDER;j++)
{
signal[i]+=a[j]*signal[i-j];
}
}
//using the memory
for(i=TILT_ORDER-1;i>=0;i--)
{
j=1;
while( (i-j)>=0 )
{
signal[i]+=a[j]*signal[i-j];
j++;
}
k=TILT_ORDER-1;
while(j<=TILT_ORDER)
{
signal[i]+=a[j]*mem[k];
j++;
k--;
}
}
//update the memory
for(i=0;i -1e-10))
{
mem[i] =0.0;
}
}
return;
}
/************************************************************************/
/* the inverse procedure of E_UTIL_tilt */
/************************************************************************/
void E_UTIL_detilt(Float32 *signal, Float32 *a, Word32 L, Float32 *mem)
{
int i,j,k;
Float32 temp;
for(i=0;i0 && j<=TILT_ORDER)
{
temp-=a[j++]*signal[--k];
}
k=0;
//using the memory
while(j<=TILT_ORDER)
{
temp-=a[j++]*mem[(TILT_ORDER-1)-(k++)];
}
signal[i]=temp;
}
//update the memory
for(i=0;i -1e-10))
{
mem[TILT_ORDER-1-i] =0.0;
}
}
return;
}
/************************************************************************/
/* Find weighted speech */
/************************************************************************/
void find_wsp_mono(float A[],
float speech[], /* speech[-M..lg] */
float wsp[], /* wsp[0..lg] */
float *mem_formant_wsp,/* memory */
float *mem_tilt_wsp,
int lg)
{
int i_subfr;
float *p_A, Ap1[M+1],Ap2[M+1],Ap3[TILT_ORDER+1];
p_A = A;
for (i_subfr=0; i_subfr