www.pudn.com > SMV_Code.rar > lib_flt.c
/*=========================================================================*/
/* Each of the companies; Ericsson, Lucent, Mindspeed, Motorola, Nokia, */
/* Nortel Networks, and Qualcomm (hereinafter referred to individually as */
/* “Source” or collectively as “Sources”) do hereby state: */
/* */
/* To the extent to which the Source(s) may legally and freely do so, */
/* the Source(s), upon submission of a Contribution, grant(s) a free, */
/* irrevocable, non-exclusive, license to the Third Generation Partnership */
/* Project 2 (3GPP2) and its Organizational Partners: ARIB, CCSA, TIA, */
/* TTA, and TTC, under the Source’s copyright or copyright license rights */
/* in the Contribution, to, in whole or in part, copy, make derivative */
/* works, perform, display and distribute the Contribution and derivative */
/* works thereof consistent with 3GPP2’s and each Organizational Partner’s */
/* policies and procedures, with the right to (i) sublicense the foregoing */
/* rights consistent with 3GPP2’s and each Organizational Partner’s */
/* policies and procedures and (ii) copyright and sell, if applicable) in */
/* 3GPP2's name or each Organizational Partner’s name any 3GPP2 or */
/* transposed Publication even though this Publication may contain the */
/* Contribution or a derivative work thereof. The Contribution shall */
/* disclose any known limitations on the Source’s rights to license as */
/* herein provided. */
/* */
/* When a Contribution is submitted by the Source(s) to assist the */
/* formulating groups of 3GPP2 or any of its Organizational Partners, */
/* it is proposed to the Committee as a basis for discussion and is not */
/* to be construed as a binding proposal on the Source(s). The Source(s) */
/* specifically reserve(s) the right to amend or modify the material */
/* contained in the Contribution. Nothing contained in the Contribution */
/* shall, except as herein expressly provided, be construed as conferring */
/* by implication, estoppel or otherwise, any license or right under */
/* (i) any existing or later issuing patent, whether or not the use of */
/* information in the document necessarily employs an invention of any */
/* existing or later issued patent, (ii) any copyright, (iii) any */
/* trademark, or (iv) any other intellectual property right. */
/* */
/* With respect to the Software necessary for the practice of any or all */
/* Normative portions of the Selectable Mode Vocoder (SMV) as it exists on */
/* the date of submittal of this form, should the SMV be approved as a */
/* Specification or Report by 3GPP2, or as a transposed Standard by any of */
/* the 3GPP2’s Organizational Partners, the Source(s) state(s) that a */
/* worldwide license to reproduce, use and distribute the Software, the */
/* license rights to which are held by the Source(s), will be made */
/* available to applicants under terms and conditions that are reasonable */
/* and non-discriminatory, which may include monetary compensation, */
/* and only to the extent necessary for the practice of any or all of the */
/* Normative portions of the SMV or the field of use of practice of the */
/* SMV Specification, Report, or Standard. The statement contained above */
/* is irrevocable and shall be binding upon the Source(s). In the event */
/* the rights of the Source(s) in and to copyright or copyright license */
/* rights subject to such commitment are assigned or transferred, */
/* the Source(s) shall notify the assignee or transferee of the existence */
/* of such commitments. */
/*=========================================================================*/
/* */
/*-------------------------------------------------------------------*/
/*===================================================================*/
/* LIBRARY: lib_flt.c */
/*-------------------------------------------------------------------*/
/* PURPOSE: Library for Filtering functions. */
/*===================================================================*/
/*----------------------------------------------------------------------------*/
/*-------------------------------- INCLUDE -----------------------------------*/
/*----------------------------------------------------------------------------*/
#include "typedef.h"
#include "main.h"
#include "mcutil.h"
#include "gputil.h"
#include "lib_flt.h"
#ifdef WMOPS
#include "const.h"
#include "lib_wmp.h"
#endif
/*----------------------------------------------------------------------------*/
/*------------------------------- FUNCTIONS ----------------------------------*/
/*----------------------------------------------------------------------------*/
/*===================================================================*/
/* FUNCTION : FLT_filterAP (). */
/*-------------------------------------------------------------------*/
/* PURPOSE : Frame data all poles filtering. */
/*-------------------------------------------------------------------*/
/* INPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) a : filter coefficients. */
/* _ (FLOAT64 []) x : input signal frame. */
/* _ (INT16) P : filter order. */
/* _ (INT16) N : number of input samples. */
/*-------------------------------------------------------------------*/
/* OUTPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) y : output signal frame. */
/*-------------------------------------------------------------------*/
/* INPUT/OUTPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) buf : input/output memory array. */
/*-------------------------------------------------------------------*/
/* RETURN ARGUMENTS : _ None. */
/*===================================================================*/
void FLT_filterAP (FLOAT64 a [], FLOAT64 x [], FLOAT64 y [], FLOAT64 buf [],
INT16 P, INT16 N)
{
/*-------------------------------------------------------------------*/
INT16 i, j;
FLOAT64 sum;
/*-------------------------------------------------------------------*/
#ifdef WMOPS
WMP_cnt_move (3*N);
WMP_cnt_mac (P*N);
WMP_cnt_move ((P-1)*N);
#endif
for (i = 0; i < N; i ++)
{
sum = x [i];
/*-----------------------------------------------------------*/
for (j = P-1; j > 0; j --)
{
sum -= (a [j] * buf [j]);
buf [j] = buf [j-1];
}
sum -= a[0]*buf[0];
/*-----------------------------------------------------------*/
buf[0] = sum;
/*-----------------------------------------------------------*/
y [i] = sum;
}
/*-------------------------------------------------------------------*/
return;
/*-------------------------------------------------------------------*/
}
/*----------------------------------------------------------------------------*/
/*===================================================================*/
/* FUNCTION : FLT_filterAZ (). */
/*-------------------------------------------------------------------*/
/* PURPOSE : Frame data all zeros filtering. */
/*-------------------------------------------------------------------*/
/* INPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) b : filter coefficients. */
/* _ (FLOAT64 []) x : input signal frame. */
/* _ (INT16) P : filter order. */
/* _ (INT16) N : number of input samples. */
/*-------------------------------------------------------------------*/
/* OUTPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) y : output signal frame. */
/*-------------------------------------------------------------------*/
/* INPUT/OUTPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) buf : input/output memory array. */
/*-------------------------------------------------------------------*/
/* RETURN ARGUMENTS : _ None. */
/*===================================================================*/
void FLT_filterAZ (FLOAT64 b [], FLOAT64 x [], FLOAT64 y [], FLOAT64 buf [],
INT16 P, INT16 N)
{
/*-------------------------------------------------------------------*/
INT16 i, j;
FLOAT64 sum;
/*-------------------------------------------------------------------*/
for (i = 0; i < N; i ++)
{
sum = 0.0;
for (j = P-1; j > 0; j --)
{
sum += buf [j] * b [j+1];
buf [j] = buf [j-1];
}
/*-----------------------------------------------------------*/
sum += (buf[0] * b [1]);
buf[0] = x[i];
/*-----------------------------------------------------------*/
y[i] = sum + (x[i] * b [0]);
}
/*-------------------------------------------------------------------*/
return;
/*-------------------------------------------------------------------*/
}
/*----------------------------------------------------------------------------*/
/*===================================================================*/
/* FUNCTION : FLT_filterPZ (). */
/*-------------------------------------------------------------------*/
/* PURPOSE : Frame data all poles-zeros filtering. */
/*-------------------------------------------------------------------*/
/* INPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) b : numerator filter coefficients. */
/* _ (FLOAT64 []) a : denominator filter coefficients. */
/* _ (FLOAT64 []) x : input signal frame. */
/* _ (INT16) P : filter order. */
/* _ (INT16) N : number of input samples. */
/*-------------------------------------------------------------------*/
/* OUTPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) y : output signal frame. */
/*-------------------------------------------------------------------*/
/* INPUT/OUTPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) buf : input/output memory array. */
/*-------------------------------------------------------------------*/
/* RETURN ARGUMENTS : _ None. */
/*===================================================================*/
void FLT_filterPZ (FLOAT64 b [], FLOAT64 a [], FLOAT64 x [], FLOAT64 y [],
FLOAT64 buf [], INT16 P, INT16 N)
{
/*-------------------------------------------------------------------*/
INT16 i, j;
FLOAT64 sum1, sum2;
/*------------------------------------------------------------------*/
for (i = 0; i < N; i ++)
{
sum1 = x [i];
sum2 = 0.0;
/*-----------------------------------------------------------*/
for (j = P-1; j > 0; j --)
{
sum2 += (b [j+1] * buf [j]);
sum1 -= (a [j] * buf [j]);
buf [j] = buf [j-1];
}
/*-----------------------------------------------------------*/
sum2 += (b [1] * buf[0]);
sum1 -= (a [0] * buf[0]);
/*-----------------------------------------------------------*/
buf[0] = sum1;
/*-----------------------------------------------------------*/
y [i] = sum2 + (buf[0] * b [0]);
}
/*-------------------------------------------------------------------*/
return;
/*-------------------------------------------------------------------*/
}
/*----------------------------------------------------------------------------*/
/*===================================================================*/
/* FUNCTION : FLT_conv (). */
/*-------------------------------------------------------------------*/
/* PURPOSE : This function perform a filtering operation */
/* */
/* The input array, x, is assumed to include past input values */
/* (NCOFS-1 values) for the filter memory, as well as new input */
/* values. The array is set up as follows: */
/* */
/* Xin(NCOFS) Xin(N+NCOFS-1) */
/* | new data | */
/* I---------II--------------------------------I */
/* | old | */
/* Xin(1) Xin(NCOFS-1) */
/* */
/* The first NCOFS-1 points of array Xin are assumed to be the */
/* "warm-up" points for the first output point, Xout(1). */
/*-------------------------------------------------------------------*/
/* INPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) x : input signal frame. */
/* _ (FLOAT64 []) a : denominator filter coefficients. */
/* _ (INT16) P : filter order. */
/* _ (INT16) N : number of input samples to be filtered. */
/*-------------------------------------------------------------------*/
/* OUTPUT ARGUMENTS : */
/* _ (FLOAT64 []) y : output signal frame. */
/*-------------------------------------------------------------------*/
/* INPUT/OUTPUT ARGUMENTS : */
/* _ (FLOAT64 []) buf : input/output memory array. */
/*-------------------------------------------------------------------*/
/* RETURN ARGUMENTS : */
/* _ None. */
/*===================================================================*/
void FLT_conv (FLOAT64 x[], FLOAT64 a[], INT16 P, INT16 N, FLOAT64 y[])
{
/*-------------------------------------------------------------------*/
INT16 i, l, k;
FLOAT64 sum;
/*-------------------------------------------------------------------*/
#ifdef WMOPS
WMP_cnt_move(2*N);
WMP_cnt_mac (P*N);
#endif
for (i = 0; i < N; i++)
{
sum = 0.0;
l = P + i;
for (k = 0; k < P; k++ )
{
l -= 1;
sum += a[k] * x[l];
}
y[i] = sum;
}
/*-------------------------------------------------------------------*/
return;
/*-------------------------------------------------------------------*/
}
/*----------------------------------------------------------------------------*/
/*===================================================================*/
/* FUNCTION : FLT_convolve (). */
/*-------------------------------------------------------------------*/
/* PURPOSE : This function calculate the convolution between */
/* two signals */
/*-------------------------------------------------------------------*/
/* INPUT ARGUMENTS : */
/* */
/* _ (FLOAT64 []) x : input signal frame. */
/* _ (FLOAT64 []) h : impulse response. */
/* _ (INT16) N : number of input samples to be filtered. */
/*-------------------------------------------------------------------*/
/* OUTPUT ARGUMENTS : */
/* _ (FLOAT64 []) y : output signal frame. */
/*-------------------------------------------------------------------*/
/* INPUT/OUTPUT ARGUMENTS : */
/* _ None. */
/*-------------------------------------------------------------------*/
/* RETURN ARGUMENTS : */
/* _ None. */
/*===================================================================*/
void FLT_convolve(FLOAT64 x [] , FLOAT64 h [], FLOAT64 y [], INT16 N)
{
/*-------------------------------------------------------------------*/
INT16 i, n;
FLOAT64 s;
/*-------------------------------------------------------------------*/
for (n = 0; n < N; n++)
{
/*-----------------------------------------------------------*/
#ifdef WMOPS
WMP_cnt_move (2);
WMP_cnt_mac (n+1);
#endif
/*-----------------------------------------------------------*/
s = 0.0;
for (i = 0; i <= n; i++)
s += x[i]*h[n-i];
y[n] = s;
/*-----------------------------------------------------------*/
}
/*-------------------------------------------------------------------*/
return;
/*-------------------------------------------------------------------*/
}
/*----------------------------------------------------------------------------*/
/*============================================================================*/
/*------------------------------------ END -----------------------------------*/
/*============================================================================*/