Merging Trimedia support contributed by Hong Zhiqian (incomplete for now)

git-svn-id: http://svn.xiph.org/trunk/speex@12764 0101bb08-14d6-0310-b084-bc0e0c8e3800

1 files changed, 479 insertions, 0 deletions

diff --git a/tmv/ltp_tm.h b/tmv/ltp_tm.h
new file mode 100644
index 0000000..eccd701
--- /dev/null
+++ b/tmv/ltp_tm.h
@@ -0,0 +1,479 @@
+/* Copyright (C) 2007 Hong Zhiqian */

+/**

+   @file ltp_tm.h

+   @author Hong Zhiqian

+   @brief Various compatibility routines for Speex (TriMedia version)

+*/

+/*

+   Redistribution and use in source and binary forms, with or without

+   modification, are permitted provided that the following conditions

+   are met:

+   

+   - Redistributions of source code must retain the above copyright

+   notice, this list of conditions and the following disclaimer.

+   

+   - Redistributions in binary form must reproduce the above copyright

+   notice, this list of conditions and the following disclaimer in the

+   documentation and/or other materials provided with the distribution.

+   

+   - Neither the name of the Xiph.org Foundation nor the names of its

+   contributors may be used to endorse or promote products derived from

+   this software without specific prior written permission.

+   

+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR

+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+*/

+#include <ops/custom_defs.h>

+#include "profile_tm.h"

+

+#ifdef FIXED_POINT

+

+#define OVERRIDE_INNER_PROD

+Int32 inner_prod(const Int16 * restrict x, const Int16 * restrict y, int len)

+{

+	register int sum = 0;

+

+	INNERPROD_START();

+

+	if ( (int)x & 0x03 == 0 && (int)y & 0x03 == 0 )

+	{

+		register int i;

+

+		len >>= 1;

+		for ( i=0 ; i<len ; i+=4 )

+		{

+			register int x0, x1, y0, y1, x2, x3, y2, y3;

+

+			x0 = ld32x(x,i);

+			y0 = ld32x(x,i);

+			x1 = ld32x(x,i+1);

+			y1 = ld32x(y,i+1);

+			sum += (ifir16(x0,y0) + ifir16(x1,y1)) >> 6;

+

+			x2 = ld32x(x,i+2);

+			y2 = ld32x(x,i+2);

+			x3 = ld32x(x,i+3);

+			y3 = ld32x(x,i+3);

+			sum += (ifir16(x2,y2) + ifir16(x3,y3)) >> 6;

+

+		}

+	} else

+	{

+		len >>= 3;

+		while( len-- )

+		{

+			register int x0, x1, x2, x3, y0, y1, y2, y3;

+

+			x0 =	pack16lsb(x[0],x[1]);

+			y0 =	pack16lsb(y[0],y[1]);

+			x1 =	pack16lsb(x[2],x[3]);

+			y1 =	pack16lsb(y[2],y[3]);

+			sum	+=	(ifir16(x0,y0) + ifir16(x1,y1)) >> 6;

+

+			x2 =	pack16lsb(x[4],x[5]);

+			y2 =	pack16lsb(y[4],y[5]);

+			x3 =	pack16lsb(x[6],x[7]);

+			y3 =	pack16lsb(y[6],y[7]);

+			sum	+=	(ifir16(x2,y2) + ifir16(x3,y3)) >> 6;

+

+			x += 8;

+			y += 8;

+		}

+	}

+

+	INNERPROD_STOP();

+	return sum;

+}

+

+#define OVERRIDE_PITCH_XCORR

+void pitch_xcorr(const Int16 *_x, const Int16 *_y, Int32 *corr, int len, int nb_pitch, char *stack)

+{

+	register int sum_1, sum_2, sum_3, sum_4;

+	register int y10, y32, y54, y76, y21, y43, y65;

+	register int x10, x32;

+	register int i, j, k, limit;

+	

+	TMDEBUG_ALIGNMEM(_x);

+	TMDEBUG_ALIGNMEM(_y);

+

+	PITCHXCORR_START();

+

+	limit	= nb_pitch >> 1;

+	len		>>= 1;

+

+	for (i=0 ; i<limit ; i+=2 )

+	{

+		sum_1 = sum_2 = sum_3 = sum_4 = 0;

+		

+		y10	= ld32x(_y,i);

+		y32	= ld32x(_y,i+1);

+		

+		for ( j=0 ; j<len ; j+=2 )

+		{

+			x10 = ld32x(_x,j);

+			x32 = ld32x(_x,j+1);

+			y54 = ld32x(_y,i+j+2);

+			y76 = ld32x(_y,i+j+3);

+			

+			sum_1 += (ifir16(x10,y10) + ifir16(x32,y32)) >> 6;

+			sum_3 += (ifir16(x10,y32) + ifir16(x32,y54)) >> 6;

+

+			y21 = funshift2(y32,y10);

+			y43 = funshift2(y54,y32);

+			y65 = funshift2(y76,y54);

+

+			sum_2 += (ifir16(x10,y21) + ifir16(x32,y43)) >> 6;

+			sum_4 += (ifir16(x10,y43) + ifir16(x32,y65)) >> 6;

+

+			y10 = y54;

+			y32 = y76;

+

+		}

+

+		k = i << 1;

+		corr[nb_pitch-1-k]=sum_1;

+		corr[nb_pitch-2-k]=sum_2;

+		corr[nb_pitch-3-k]=sum_3;

+		corr[nb_pitch-4-k]=sum_4;

+	}

+

+#ifndef REMARK_ON

+	(void)stack;

+#endif

+

+	PITCHXCORR_STOP();

+}

+

+#ifndef ttisim

+#define OVERRIDE_PITCH_GAIN_SEARCH_3TAP_VQ

+static int pitch_gain_search_3tap_vq

+(

+	const signed char	*gain_cdbk,

+	int					gain_cdbk_size,

+	Int16				*C16,

+	Int16				max_gain

+)

+{

+	register int	pp = 0x00400040, p=64;

+	register int	g10, g2, g20, g21, g02, g22, g01;

+	register int	cb0, cb1, cb2, cb5432;

+	register int	C10, C32, C54, C76, C98, C83, C2;

+	register int	acc0, acc1, acc2, acc3, sum, gsum, bsum=-VERY_LARGE32;

+	register int    i, best_cdbk=0;

+	register Int16	tmp;

+

+	TMDEBUG_ALIGNMEM(C16);

+	TMDEBUG_ALIGNMEM(gain_cdbk+2);

+

+	PITCHGAINSEARCH3TAPVQ_START();

+

+	tmp  = ild16(gain_cdbk);

+	C98	 = ld32x(C16,4);

+	C32	 = ld32x(C16,1);

+	C10  = ld32(C16);

+	C54	 = ld32x(C16,2);

+	C76	 = ld32x(C16,3);

+

+	cb0  = sex8(tmp);

+	cb1	 = sex8(tmp>>8);

+	C83	 = funshift2(C98,C32);

+	C2	 = sex16(C32);

+	gain_cdbk += 2;

+

+

+#if (TM_UNROLL && TM_UNROLL_PITCHGAINSEARCH3TAPVQ > 0)

+#pragma TCS_unroll=4

+#pragma TCS_unrollexact=1

+#endif

+	for ( i=0 ; i<gain_cdbk_size ; ++i ) 

+	{

+         cb5432 = ld32x(gain_cdbk,i);

+		 cb2	= sex8(cb5432);

+		 gsum	= sex8(cb5432>>8);

+		 sum	= 0;

+		 

+		 g10	=  pack16lsb(cb1 + 32, cb0 + 32);

+		 g2		=  cb2 + 32;

+		 g02	=  pack16lsb(g10, g2);

+		 acc0	=  dspidualmul(g10,pp);

+		 sum	+= ifir16(acc0,C10);

+		 sum	+= p * g2 * C2;

+

+		 g22	=  pack16lsb(g02, g02);

+		 g01	=  funshift2(g10, g10);

+

+		 acc1	=  dspidualmul(g22, g01);

+		 sum	-= ifir16(acc1, C54);

+		 acc2	=  dspidualmul(g10, g10);

+		 sum	-= ifir16(acc2, C76);

+

+		 g20	=  pack16lsb(g2, g10);

+		 g21	=  funshift2(g2, g10);

+		 acc3	=  dspidualmul(g20, g21);

+		 sum	-= ifir16(acc3, C83);

+	

+

+		if ( sum>bsum && gsum<=max_gain ) 

+		{	bsum = sum;

+			best_cdbk=i;

+		}

+

+		cb0	= sex8(cb5432 >> 16);

+		cb1	= asri(24,cb5432);

+	}

+#if (TM_UNROLL && TM_UNROLL_PITCHGAINSEARCH3TAPVQ > 0)

+#pragma TCS_unrollexact=0

+#pragma TCS_unroll=0

+#endif

+

+	PITCHGAINSEARCH3TAPVQ_STOP();

+	return best_cdbk;

+}

+#endif

+

+#define OVERRIDE_COMPUTE_PITCH_ERROR

+#ifndef OVERRIDE_PITCH_GAIN_SEARCH_3TAP_VQ

+inline Int32 compute_pitch_error(Int16 *C, Int16 *g, Int16 pitch_control)

+{

+	register int c10, c32, c54, c76, c98, c83;

+	register int g10, g32, g02, g22, g01, g21, g20;

+	register int pp, tmp0, tmp1, tmp2, tmp3;

+	register int sum = 0;

+

+	

+	COMPUTEPITCHERROR_START();

+

+	g10  =  ld32(g);

+	g32  =  ld32x(g,1);

+	pp   =  pack16lsb(pitch_control,pitch_control);

+	c10  =  ld32(C);

+	c32  =  ld32x(C,1);

+	g02  =  pack16lsb(g10,g32);

+	g22	 =  pack16lsb(g32,g32);

+	g01  =  funshift2(g10,g10);

+	tmp0 =  dspidualmul(g10,pp);

+	sum  += ifir16(tmp0, c10);

+	sum  += pitch_control * sex16(g32) * sex16(c32);

+	c54  =  ld32x(C,2);

+	c76  =  ld32x(C,3);

+	c98  =  ld32x(C,4);

+	tmp1 =  dspidualmul(g22,g01);

+	sum  -= ifir16(tmp1, c54);

+	tmp2 =  dspidualmul(g10,g10);

+	sum  -= ifir16(tmp2,c76);

+	c83  =  funshift2(c98,c32);

+	g20	 =  funshift2(g02,g02);

+	g21  =  funshift2(g02,g10);

+	tmp3 =  dspidualmul(g20,g21);

+	sum	 -= ifir16(tmp3,c83);

+

+	COMPUTEPITCHERROR_STOP();

+    return sum;

+}

+#endif

+

+#define OVERRIDE_OPEN_LOOP_NBEST_PITCH

+void open_loop_nbest_pitch(Int16 *sw, int start, int end, int len, int *pitch, Int16 *gain, int N, char *stack)

+{

+	VARDECL(int *best_score);

+	VARDECL(int *best_ener);

+	VARDECL(Int32 *corr);

+	VARDECL(Int16 *corr16);

+	VARDECL(Int16 *ener16);

+	register int i, j, k, l, N4, N2;

+	register int _sw10, _sw32, _s0, _s2, limit;

+	register int *energy;

+	register int cshift=0, eshift=0;

+	register int scaledown = 0;

+	register int e0, _energy0;

+

+	ALLOC(corr16, end-start+1, Int16);

+	ALLOC(ener16, end-start+1, Int16);

+	ALLOC(corr, end-start+1, Int32);

+	ALLOC(best_score, N, int);

+	ALLOC(best_ener, N, int);

+	energy = corr;

+	N4 = N << 2;

+	N2 = N >> 1;

+

+	TMDEBUG_ALIGNMEM(sw);

+	TMDEBUG_ALIGNMEM(pitch);

+	TMDEBUG_ALIGNMEM(gain);

+	TMDEBUG_ALIGNMEM(best_score);

+	TMDEBUG_ALIGNMEM(best_ener);

+	TMDEBUG_ALIGNMEM(corr16);

+	TMDEBUG_ALIGNMEM(ener16);

+

+	OPENLOOPNBESTPITCH_START();

+

+	for ( i=0 ; i<N4 ; i+=4 )

+	{	st32d(i,best_score,-1);

+		st32d(i,best_ener,0);

+		st32d(i,pitch,start);

+	}

+

+	for ( j=asri(1,-end) ; j<N2 ; ++j )

+	{	register int _sw10;

+

+		_sw10 = ld32x(sw,j);

+		_sw10 = dspidualabs(_sw10);

+

+		if ( _sw10 & 0xC000C000 )

+		{	scaledown = 1;

+			break;

+		}

+	}

+

+	if ( scaledown )

+	{

+		for ( j=asri(1,-end),k=asli(1,-end) ; j<N2 ; ++j,k+=4 )

+		{	register int _sw10;

+		

+			_sw10 = ld32x(sw,j);

+			_sw10 = dualasr(_sw10,1);

+			st32d(k, sw, _sw10);

+		}

+	}      

+

+	energy[0] = _energy0 = inner_prod(sw-start, sw-start, len);

+	e0 = inner_prod(sw, sw, len);

+

+	j=asri(1,-start-1); k=j+20;

+	_sw10 = ld32x(sw,j);

+	_sw32 = ld32x(sw,k);

+	limit = end-1-start;

+

+	for ( i=1,--j,--k ; i<limit ; i+=2,--j,--k )

+	{	register int _energy1, __sw10, __sw32, __s0, __s2;

+      

+		_s0    = sex16(_sw10);

+		_s2	   = sex16(_sw32);

+		_energy1 = (_energy0 + ((_s0 * _s0) >> 6)) -  ((_s2 * _s2) >> 6);

+		_energy0 = imax(0,_energy1);

+		energy[i] = _energy0;

+		__sw10 = ld32x(sw,j);

+		__sw32 = ld32x(sw,k);

+		__s0   = asri(16,__sw10);

+		__s2   = asri(16,__sw32);

+		_energy1 = (_energy0 + ((__s0 * __s0) >> 6)) -  ((__s2 * __s2) >> 6);

+		_energy0 = imax(0,_energy1);

+		energy[i+1] = _energy0;

+		_sw10 = __sw10;

+		_sw32 = __sw32;

+	}

+

+	_s0    = sex16(_sw10);

+	_s2	   = sex16(_sw32);

+	_energy0 = imax(0,(_energy0 + ((_s0 * _s0) >> 6)) -  ((_s2 * _s2) >> 6));

+	energy[i] = _energy0;

+

+

+	eshift = normalize16(energy, ener16, 32766, end-start+1); 

+	/* In fixed-point, this actually overrites the energy array (aliased to corr) */

+	pitch_xcorr(sw, sw-end, corr, len, end-start+1, stack);

+	/* Normalize to 180 so we can square it and it still fits in 16 bits */

+	cshift = normalize16(corr, corr16, 180, end-start+1);

+	/* If we scaled weighted input down, we need to scale it up again (OK, so we've just lost the LSB, who cares?) */

+   

+	if ( scaledown )

+	{

+		for ( j=asri(1,-end),k=asli(1,-end) ; j<N2 ; ++j,k+=4 )

+		{	register int _sw10;

+			

+			_sw10 = ld32x(sw,j);

+			_sw10 = dualasl(_sw10,1);

+			st32d(k, sw, _sw10);

+		}

+	}      

+

+	/* Search for the best pitch prediction gain */

+	for ( i=start,l=0 ; i<end ; i+=2,++l )

+	{	register int _corr16, _c0, _c1;

+		register int _ener16, _e0, _e1;

+

+		_corr16 = ld32x(corr16,l);

+		_corr16 = dspidualmul(_corr16,_corr16);

+		_c0     = sex16(_corr16);

+		_c1     = asri(16,_corr16);

+

+		_ener16 = ld32x(ener16,l);

+		_ener16 = dspidualadd(_ener16,0x00010001);

+		_e0	    = sex16(_ener16);

+		_e1     = asri(16,_ener16);

+

+      /* Instead of dividing the tmp by the energy, we multiply on the other side */

+      

+		if ( (_c0 * best_ener[N-1]) > (best_score[N-1] * _e0) )

+		{	

+			best_score[N-1] = _c0;

+			best_ener[N-1] = _e0;

+			pitch[N-1] = i;

+

+			for( j=0 ; j<N-1 ; ++j )

+			{	if ( (_c0 * best_ener[j]) > best_score[j] * _e0 )

+				{	for( k=N-1 ; k>j ; --k )

+					{

+						best_score[k]=best_score[k-1];

+						best_ener[k]=best_ener[k-1];

+						pitch[k]=pitch[k-1];

+					}

+

+			        best_score[j]=_c0;

+					best_ener[j]=_e0;

+					pitch[j]=i;

+					break;

+				}

+			}

+		}

+

+		if ( (_c1 * best_ener[N-1]) > (best_score[N-1] * _e1) )

+		{	

+			best_score[N-1] = _c1;

+			best_ener[N-1] = _e1;

+			pitch[N-1] = i+1;

+

+			for( j=0 ; j<N-1 ; ++j )

+			{	if ( (_c1 * best_ener[j]) > best_score[j] * _e1 )

+				{	for( k=N-1 ; k>j ; --k )

+					{

+						best_score[k]=best_score[k-1];

+						best_ener[k]=best_ener[k-1];

+						pitch[k]=pitch[k-1];

+					}

+

+			        best_score[j]=_c1;

+					best_ener[j]=_e1;

+					pitch[j]=i+1;

+					break;

+				}

+			}

+		}

+   }

+   

+   /* Compute open-loop gain if necessary */

+   if (gain)

+   {

+		for (j=0;j<N;j++)

+		{

+			spx_word16_t g;

+			i=pitch[j];

+			g = DIV32(SHL32(EXTEND32(corr16[i-start]),cshift), 10+SHR32(MULT16_16(spx_sqrt(e0),spx_sqrt(SHL32(EXTEND32(ener16[i-start]),eshift))),6));

+		 	gain[j] = imax(0,g);

+		}

+	}

+

+	OPENLOOPNBESTPITCH_STOP();

+}

+

+

+#endif

+