📄 filters_tm.h

📁 一个开源的sip源代码
💻 H
📖 第 1 页 / 共 3 页
字号:
12 3 下一页
#include <ops/custom_defs.h>
#include "profile_tm.h"

#ifdef FIXED_POINT

#define iadd(a,b)	((a) + (b))

#define OVERRIDE_BW_LPC
void bw_lpc(Int16 gamma, const Int16 *lpc_in, Int16 *lpc_out, int order)
{
	register int tmp, g, i;
	
	TMDEBUG_ALIGNMEM(lpc_in);
	TMDEBUG_ALIGNMEM(lpc_out);

	BWLPC_START();

	tmp = g = gamma;
	for ( i=0 ; i<4 ; i+=2,lpc_out+=4 )
	{	register int in10, y1, y0, y10;
		register int in32, y3, y2, y32;

		in10 = ld32x(lpc_in,i);
		y0	 = ((tmp * sex16(in10)) + 16384) >> 15;
		tmp  = ((tmp * g) + 16384) >> 15;
		y1	 = ((tmp * asri(16,in10)) + 16384) >> 15;
		tmp  = ((tmp * g) + 16384) >> 15;
		y10  =  pack16lsb(y1,y0);
		st32(lpc_out,y10);

		in32 = ld32x(lpc_in,i+1);
		y2	 = ((tmp * sex16(in32)) + 16384) >> 15;
		tmp  = ((tmp * g) + 16384) >> 15;
		y3	 = ((tmp * asri(16,in32)) + 16384) >> 15;
		tmp  = ((tmp * g) + 16384) >> 15;
		y32  =  pack16lsb(y3,y2);
		st32d(4,lpc_out,y32);
	}

	if ( order == 10 )
	{	register int in10, y1, y0, y10;
		
		in10 = ld32x(lpc_in,i);
		y0	 = ((tmp * sex16(in10)) + 16384) >> 15;
		tmp  = ((tmp * g) + 16384) >> 15;
		y1	 = ((tmp * asri(16,in10)) + 16384) >> 15;
		tmp  = ((tmp * g) + 16384) >> 15;
		y10  =  pack16lsb(y1,y0);
		st32(lpc_out,y10);
	}

	BWLPC_STOP();
}


#define OVERRIDE_HIGHPASS
void highpass(const Int16 *x, Int16 *y, int len, int filtID, Int32 *mem)
{
   	const Int16 Pcoef[5][3] = {{16384, -31313, 14991}, {16384, -31569, 15249}, {16384, -31677, 15328}, {16384, -32313, 15947}, {16384, -22446, 6537}};
	const Int16 Zcoef[5][3] = {{15672, -31344, 15672}, {15802, -31601, 15802}, {15847, -31694, 15847}, {16162, -32322, 16162}, {14418, -28836, 14418}};
	register int i;
	register int den1, den2, num0, num1, num2, den11, den22, mem0, mem1;
   
	TMDEBUG_ALIGNMEM(mem);

	HIGHPASS_START();

	filtID = imin(4, filtID);

	den1 = -Pcoef[filtID][1];
	den2 = -Pcoef[filtID][2];
	num0 = Zcoef[filtID][0];
	num1 = Zcoef[filtID][1];
	num2 = Zcoef[filtID][2];
	den11 = den1 << 1;
	den22 = den2 << 1;
	mem0 = mem[0];
	mem1 = mem[1];
	
#if (TM_UNROLL && TM_UNROLL_HIGHPASS)
#pragma TCS_unroll=4
#pragma TCS_unrollexact=1
#endif
	for ( i=0 ; i<len ; ++i )
	{
		register int yi;
		register int vout, xi, vout_i, vout_d;
			
		xi = x[i];

		vout	= num0 * xi + mem0;
		vout_i	= vout >> 15;
		vout_d	= vout & 0x7FFF;
		yi		= iclipi(PSHR32(vout,14),32767);
		mem0	= (mem1 + num1 * xi) + (den11 * vout_i) + (((den1 * vout_d) >> 15) << 1);
		mem1	= (num2 * xi) + (den22 * vout_i) + (((den2 *  vout_d) >> 15) << 1);
		
		y[i] = yi;
	}
#if (TM_UNROLL && TM_UNROLL_HIGHPASS)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif

	mem[0] = mem0;
	mem[1] = mem1;

	HIGHPASS_STOP();
}


#define OVERRIDE_SIGNALMUL
void signal_mul(const Int32 *x, Int32 *y, Int32 scale, int len)
{
	register int i, scale_i, scale_d;
   
	SIGNALMUL_START();

	scale_i = scale >> 14;
	scale_d = scale & 0x3FFF;

#if (TM_UNROLL && TM_UNROLL_SIGNALMUL)
#pragma TCS_unroll=4
#pragma TCS_unrollexact=1
#endif
	for ( i=0 ; i<len ; ++i)
	{
		register int xi;

		xi = x[i] >> 7;

		y[i] = ((xi * scale_i + ((xi * scale_d) >> 14)) << 7);
			
	}
#if (TM_UNROLL && TM_UNROLL_SIGNALMUL)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif

	SIGNALMUL_STOP();
}

#define OVERRIDE_SIGNALDIV
void signal_div(const Int16 *x, Int16 *y, Int32 scale, int len)
{
	register int i;
   
	SIGNALDIV_START();

	if (scale > SHL32(EXTEND32(SIG_SCALING), 8))
	{
		register int scale_1;
		scale	= PSHR32(scale, SIG_SHIFT);
		scale_1 = DIV32_16(SHL32(EXTEND32(SIG_SCALING),7),scale);
#if (TM_UNROLL && TM_UNROLL_SIGNALDIV)
#pragma TCS_unroll=4
#pragma TCS_unrollexact=1
#endif
		for ( i=0 ; i<len ; ++i)
		{
			y[i] = MULT16_16_P15(scale_1, x[i]);
		}
#if (TM_UNROLL && TM_UNROLL_SIGNALDIV)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
	} else if (scale > SHR32(EXTEND32(SIG_SCALING), 2)) {
      
		register int scale_1;
		scale	= PSHR32(scale, SIG_SHIFT-5);
		scale_1 = DIV32_16(SHL32(EXTEND32(SIG_SCALING),3),scale);
#if (TM_UNROLL && TM_UNROLL_SIGNALDIV)
#pragma TCS_unroll=4
#pragma TCS_unrollexact=1
#endif
		for (i=0;i<len;i++)
		{
			y[i] = PSHR32(MULT16_16(scale_1, SHL16(x[i],2)),8);
		}
#if (TM_UNROLL && TM_UNROLL_SIGNALDIV)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
	} else {
		
		register int scale_1;
		scale = PSHR32(scale, SIG_SHIFT-7);
		scale = imax(5,scale);
		scale_1 = DIV32_16(SHL32(EXTEND32(SIG_SCALING),3),scale);

#if (TM_UNROLL && TM_UNROLL_SIGNALDIV)
#pragma TCS_unroll=4
#pragma TCS_unrollexact=1
#endif
		for (i=0;i<len;i++)
		{
			 y[i] = PSHR32(MULT16_16(scale_1, SHL16(x[i],2)),6);
		}
#if (TM_UNROLL && TM_UNROLL_SIGNALDIV)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
	}

	SIGNALMUL_STOP();
}


#define OVERRIDE_COMPUTE_RMS
Int16 compute_rms(const Int32 *x, int len)
{
	register int i;
	register int sum=0;
	register int max_val=1;
	register int sig_shift;
	
	TMDEBUG_ALIGNMEM(x);

	for ( i=0 ; i<len ; i+=4 )
	{
		register int tmp0, tmp1, tmp2, tmp3;

		tmp0 = ld32x(x,i);
		tmp1 = ld32x(x,i+1);

		tmp0 = iabs(tmp0);
		tmp1 = iabs(tmp1);

		tmp2 = ld32x(x,i+2);
		tmp3 = ld32x(x,i+3);

		tmp2 = iabs(tmp2);
		tmp3 = iabs(tmp3);

		tmp0 = imax(tmp0, tmp1);
		max_val = imax(max_val, tmp0); 
		tmp2 = imax(tmp2, tmp3);		
		max_val = imax(max_val, tmp2);
	}

	sig_shift = 0;
	while ( max_val>16383 )
	{	sig_shift++;
		max_val >>= 1;
	}


	for ( i=0 ; i<len ; i+=4 )
	{
		register int acc0, acc1, acc2;

		acc0 =  pack16lsb(ld32x(x,i) >> sig_shift, ld32x(x,i+1) >> sig_shift);
		acc1 =  pack16lsb(ld32x(x,i+2) >> sig_shift, ld32x(x,i+3) >> sig_shift);
		acc2 =  ifir16(acc0,acc0) + ifir16(acc1, acc1);
		sum	 += acc2 >> 6;
	}
   
   return EXTRACT16(PSHR32(SHL32(EXTEND32(spx_sqrt(DIV32(sum,len))),(sig_shift+3)),SIG_SHIFT));
}

#define OVERRIDE_COMPUTE_RMS16
Int16 compute_rms16(const Int16 *x, int len)
{
	register int max_val, i;
	
	COMPUTERMS16_START();
	
	max_val = 10;

#if 0

	{
		register int len2 = len >> 1;
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unroll=2
#pragma TCS_unrollexact=1
#endif
		for ( i=0 ; i<len2 ; i+=2 )
		{
			register int x10, x32;

			x10 = ld32x(x,i);
			x32 = ld32x(x,i+1);
			 
			x10 = dspidualabs(x10);
			x32 = dspidualabs(x32);
			
			x10 = imax(sex16(x10), asri(16,x10));
			x32 = imax(sex16(x32), asri(16,x32));
			
			max_val = imax(max_val,x10);
			max_val = imax(max_val,x32);
		}
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
		if (max_val>16383)
		{
			register int sum = 0;
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unroll=2
#pragma TCS_unrollexact=1
#endif
			for ( i=0 ; i<len_2; i+=2 )
			{
				register int x10, x32;
				register int acc0, acc1;

				x10 = ld32x(x,i);
				x32 = ld32x(x,i+1);
				
				x10 = dualasr(x10,1);
				x32 = dualasr(x32,1);

				acc0 = ifir16(x10,x10);
				acc1 = ifir16(x32,x32);
				sum  += (acc0 + acc1) >> 6;
			}
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
			COMPUTERMS16_STOP();
			return spx_sqrt(sum/len) << 4;
		} else 
		{
			register int sig_shift;
			register int sum=0;

			sig_shift = mux(max_val < 8192, 1, 0);
			sig_shift = mux(max_val < 4096, 2, sig_shift);
			sig_shift = mux(max_val < 2048, 3, sig_shift);

#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unroll=2
#pragma TCS_unrollexact=1
#endif
			for ( i=0 ; i<len_2 ; i+=2 )
			{
				register int x10, x32;
				register int acc0, acc1;

				x10 = ld32x(x,i);
				x32 = ld32x(x,i+1);

				x10 = dualasl(x10,sig_shift);
				x32 = dualasl(x32,sig_shift);
				
				acc0 = ifir16(x10,x10);
				acc1 = ifir16(x32,x32);
				sum  += (acc0 + acc1) >> 6;
			}
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
			COMPUTERMS16_STOP();
			return spx_sqrt(sum/len) << (3 - sig_shift);  
		}
	}

#else
	{
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unroll=4
#pragma TCS_unrollexact=1
#endif
		for ( i=0 ; i<len ; ++i )
		{
			register int xi;

			xi = x[i];
			xi = iabs(xi);
			max_val = imax(xi,max_val);
		}
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
		if (max_val>16383)
		{
			register int sum = 0;
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unroll=2
#pragma TCS_unrollexact=1
#endif
			for ( i=0 ; i<len ; i+=4 )
			{
				register int x10, x32;
				register int acc0, acc1;

				x10 = pack16lsb(x[i+1],x[i]);
				x32 = pack16lsb(x[i+3],x[i+2]);
				
				x10 = dualasr(x10,1);
				x32 = dualasr(x32,1);

				acc0 = ifir16(x10,x10);
				acc1 = ifir16(x32,x32);
				sum  += (acc0 + acc1) >> 6;
			}
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
			COMPUTERMS16_STOP();
			return spx_sqrt(sum/len) << 4;
		} else {
			register int sig_shift;
			register int sum=0;

			sig_shift = mux(max_val < 8192, 1, 0);
			sig_shift = mux(max_val < 4096, 2, sig_shift);
			sig_shift = mux(max_val < 2048, 3, sig_shift);

#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unroll=2
#pragma TCS_unrollexact=1
#endif
			for ( i=0 ; i<len ; i+=4 )
			{
				register int x10, x32;
				register int acc0, acc1;

				x10 = pack16lsb(x[i+1],x[i]);
				x32 = pack16lsb(x[i+3],x[i+2]);

				x10 = dualasl(x10,sig_shift);
				x32 = dualasl(x32,sig_shift);
				
				acc0 = ifir16(x10,x10);
				acc1 = ifir16(x32,x32);
				sum  += (acc0 + acc1) >> 6;
			}
#if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)
#pragma TCS_unrollexact=0
#pragma TCS_unroll=0
#endif
			COMPUTERMS16_STOP();
			return spx_sqrt(sum/len) << (3 - sig_shift);  
		}
	}
#endif
}

int normalize16_9(const Int32* restrict x, Int16 * restrict y, Int32 max_scale)
{
	register int x0, x1, x2, x3, x4, x5, x6, x7, x8;
	register int max_val, m0, m1, m2, m3, m4;
	register int sig_shift;
	register int y10, y32, y54, y76;

	TMDEBUG_ALIGNMEM(x);

	x0 = ld32(x); 
	x1 = ld32x(x,1); x2 = ld32x(x,2); x3 = ld32x(x,3); x4 = ld32x(x,4); 
	x5 = ld32x(x,5); x6 = ld32x(x,6); x7 = ld32x(x,7); x8 = ld32x(x,8);

	m0 = imax(iabs(x0), iabs(x1));
	m1 = imax(iabs(x2), iabs(x3));
	m2 = imax(iabs(x4), iabs(x5));
	m3 = imax(iabs(x6), iabs(x7));
	m4 = imax(m0, iabs(x8));
	m1 = imax(m1, m2);
	m3 = imax(m3, m4);
	max_val = imax(1,imax(m1,m3));

	sig_shift=0;
	while (max_val>max_scale)
	{	sig_shift++;
		max_val >>= 1;
	}

	if ( sig_shift != 0 )
	{
		y10 = pack16lsb(x1 >> sig_shift, x0 >> sig_shift);
		y32 = pack16lsb(x3 >> sig_shift, x2 >> sig_shift);
		y54 = pack16lsb(x5 >> sig_shift, x4 >> sig_shift);
		y76 = pack16lsb(x7 >> sig_shift, x6 >> sig_shift);

		y[8] = x8 >> sig_shift;
		st32(y,y10);
		st32d(4,y,y32);
		st32d(8,y,y54);
		st32d(12,y,y76);
	}
	return sig_shift;
}

int normalize16_mod8(const Int32 * restrict x, Int16 * restrict y, Int32 max_scale,int len)
{
	register int i, max_val, sig_shift;
	
	TMDEBUG_ALIGNMEM(x);

	max_val = 1;

	for ( i=0 ; i<len ; i+=4 )
	{
		register int tmp0, tmp1, tmp2, tmp3;

		tmp0 = ld32x(x,i);
		tmp1 = ld32x(x,i+1);

		tmp0 = iabs(tmp0);
		tmp1 = iabs(tmp1);
12 3 下一页
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -