mat_lib.c

MELPe 1200 bps, fixed point

	L_temp = 0;
	for (i = 0; i < n; i++){
		L_temp = L_mac(L_temp, *vec1, *vec2);
		vec1 ++;
		vec2 ++;
	}

	/* L_temp is now (qvec1 + qvec2 + 1) */
	shift = sub(qout, add(add(qvec1, qvec2), 1));
	L_innerprod = L_shl(L_temp, shift);
	return(L_innerprod);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: v_magsq
 *
 *	 PURPOSE:
 *
 *	   Compute the sum of square magnitude of a 16 bit input vector
 *	   with saturation and truncation.	Output is a 16 bit number.
 *
 *	 INPUTS:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *	   n			   size of input vectors
 *
 *	   qvec1		   Q value of vec1
 *
 *	   qout 		   Q value of output
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   magsq		   16 bit short signed integer (Shortword) whose value
 *					   falls in the range
 *					   0xffff 8000 <= magsq <= 0x0000 7fff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Compute the sum of square magnitude of a 16 bit input vector.
 *	   The output is a 16 bit number.
 *
 *	 KEYWORDS: square magnitude
 *
 *************************************************************************/

Shortword v_magsq(Shortword vec1[], Shortword n, Shortword qvec1,
				  Shortword qout)
{
	register Shortword	i;
	Shortword	shift;
	Shortword	magsq;
	Longword	L_temp;


	L_temp = 0;
	for (i = 0; i < n; i++){
		L_temp = L_mac(L_temp, *vec1, *vec1);
		vec1 ++;
	}
	/* qout - ((2*qvec1 + 1) - 16) */
	shift = sub(qout, sub(add(shl(qvec1, 1), 1), 16));
	magsq = extract_h(L_shl(L_temp, shift));
	return(magsq);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: L_v_magsq
 *
 *	 PURPOSE:
 *
 *	   Compute the sum of square magnitude of a 16 bit input vector
 *	   with saturation and truncation.	Output is a 32 bit number.
 *
 *	 INPUTS:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *	   n			   size of input vectors
 *
 *	   qvec1		   Q value of vec1
 *
 *	   qout 		   Q value of output
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   L_magsq		   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0000 <= L_magsq <= 0x7fff ffff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Compute the sum of square magnitude of a 16 bit input vector.
 *	   The output is a 32 bit number.
 *
 *	 KEYWORDS: square magnitude
 *
 *************************************************************************/

Longword L_v_magsq(Shortword vec1[], Shortword n, Shortword qvec1,
				   Shortword qout)
{
	register Shortword	i;
	Shortword	shift;
	Longword	L_magsq, L_temp;


	L_temp = 0;
	for (i = 0; i < n; i++){
		L_temp = L_mac(L_temp, *vec1, *vec1);
		vec1 ++;
	}
	/* ((qout-16)-((2*qvec1+1)-16)) */
	shift = sub(sub(qout, shl(qvec1, 1)), 1);
	L_magsq = L_shl(L_temp, shift);
	return(L_magsq);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: v_scale
 *
 *	 PURPOSE:
 *
 *	   Perform a multipy of the 16 bit input vector with a 16 bit input
 *	   scale with saturation and truncation.
 *
 *	 INPUTS:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) vector whose
 *					   values fall in the range
 *					   0xffff 8000 <= vec1 <= 0x0000 7fff.
 *	   scale
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *
 *	   n			   size of vec1
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) vector whose
 *					   values fall in the range
 *					   0xffff 8000 <= vec1[] <= 0x0000 7fff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Perform a multipy of the 16 bit input vector with the 16 bit input
 *	   scale.  The output is a 16 bit vector.
 *
 *	 KEYWORDS: scale
 *
 *************************************************************************/

Shortword *v_scale(Shortword vec1[], Shortword scale, Shortword n)
{
	register Shortword	i;


	for (i = 0; i < n; i++){
		*vec1 = mult(*vec1, scale);
		vec1 ++;
	}
	return(vec1 - n);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: v_scale_shl
 *
 *	 PURPOSE:
 *
 *	   Perform a multipy of the 16 bit input vector with a 16 bit input
 *	   scale and shift to left with saturation and truncation.
 *
 *	 INPUTS:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) vector whose
 *					   values fall in the range
 *					   0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *	   scale		   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *
 *	   n			   size of vec1
 *
 *	   shift		   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0x0000 0000 <= var1 <= 0x0000 1f.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) vector whose
 *					   values fall in the range
 *					   0xffff 8000 <= vec1[] <= 0x0000 7fff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Perform a multipy of the 16 bit input vector with the 16 bit input
 *	   scale.  The output is a 16 bit vector.
 *
 *	 KEYWORDS: scale
 *
 *************************************************************************/

Shortword *v_scale_shl(Shortword vec1[], Shortword scale, Shortword n,
					   Shortword shift)
{
	register Shortword	i;


	for (i = 0; i < n; i++){
		*vec1 = extract_h(L_shl(L_mult(*vec1, scale), shift));
		vec1 ++;
	}
	return(vec1 - n);
}

/***************************************************************************
 *
 *	 FUNCTION NAME: v_sub
 *
 *	 PURPOSE:
 *
 *	   Perform the subtraction of the two 16 bit input vector with
 *	   saturation.
 *
 *	 INPUTS:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) vector whose
 *					   values fall in the range
 *					   0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *	   vec2 		   16 bit short signed integer (Shortword) vector whose
 *					   values falls in the range
 *					   0xffff 8000 <= vec2 <= 0x0000 7fff.
 *
 *	   n			   size of input vectors.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) vector whose
 *					   values fall in the range
 *					   0xffff 8000 <= vec1[] <= 0x0000 7fff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Perform the subtraction of the two 16 bit input vectors with
 *	   saturation.
 *
 *	   vec1 = vec1 - vec2
 *
 *	   vec1[] is set to 0x7fff if the operation results in an
 *	   overflow.  vec1[] is set to 0x8000 if the operation results
 *	   in an underflow.
 *
 *	 KEYWORDS: sub, subtraction
 *
 *************************************************************************/

Shortword *v_sub(Shortword vec1[], const Shortword vec2[], Shortword n)
{
	register Shortword	i;


	for (i = 0; i < n; i++){
		*vec1 = sub(*vec1, *vec2);
		vec1 ++;
		vec2 ++;
	}

	return(vec1 - n);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: v_zap
 *
 *	 PURPOSE:
 *
 *	   Set the elements of a 16 bit input vector to zero.
 *
 *	 INPUTS:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) vector whose
 *					   values fall in the range
 *					   0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *	   n			   size of vec1.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   vec1 		   16 bit short signed integer (Shortword) vector whose
 *					   values are equal to 0x0000 0000.
 *
 *	 IMPLEMENTATION:
 *
 *	   Set the elements of 16 bit input vector to zero.
 *
 *	   vec1 = 0
 *
 *	 KEYWORDS: zap, clear, reset
 *
 *************************************************************************/
Shortword *v_zap(Shortword vec1[], Shortword n)
{
	register Shortword	i;


	for (i = 0; i < n; i++){
		*vec1 = 0;
		vec1 ++;
	}
	return(vec1 - n);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: L_v_zap
 *
 *	 PURPOSE:
 *
 *	   Set the elements of a 32 bit input vector to zero.
 *
 *	 INPUTS:
 *
 *	   L_vec1		   32 bit long signed integer (Longword) vector whose
 *					   values fall in the range
 *					   0x8000 0000 <= vec1 <= 0x7fff ffff.
 *
 *	   n			   size of L_vec1.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   L_vec1		   32 bit long signed integer (Longword) vector whose
 *					   values are equal to 0x0000 0000.
 *
 *	 IMPLEMENTATION:
 *
 *	   Set the elements of 32 bit input vector to zero.
 *
 *	   L_vec1 = 0
 *
 *	 KEYWORDS: zap, clear, reset
 *
 *************************************************************************/

Longword *L_v_zap(Longword L_vec1[], Shortword n)
{
	register Shortword	i;


	for (i = 0; i < n; i++){
		*L_vec1 = 0;
		L_vec1 ++;
	}

	return(L_vec1 - n);
}


Shortword *v_get(Shortword n)
{
	Shortword	*ptr;
	Longword	size;


	size = sizeof(Shortword) * n;
	ptr = malloc(size);
	assert(ptr != NULL);
	return(ptr);
}


Longword *L_v_get(Shortword n)
{
	Longword	*ptr;
	Longword	size;


	size = sizeof(Longword) * n;
	ptr = malloc(size);
	assert(ptr != NULL);
	return(ptr);
}


void v_free(void *v)
{
	if (v)
		free(v);
}