c语言写的fir低通滤波器

合集下载

FIR滤波器设计C语言程序

FIR滤波器设计C语言程序FIR滤波器设计C语言程序1. 引言2. FIR滤波器原理FIR滤波器的输入输出关系可以表示为以下方程：y[n] = h[0]x[n] + h[1]x[n-1] + + h[M]x[n-M]其中，y[n]为输出信号，x[n]为输入信号，h为FIR滤波器的系数向量，M为滤波器的阶数。

3. 窗函数法设计FIR滤波器窗函数法是一种简单有效的FIR滤波器设计方法，其思想是通过加窗和傅里叶变换来确定滤波器系数。

步骤如下：1. 确定滤波器的阶数M，一般通过信号频率响应要求来确定。

2. 选择一个窗函数（如矩形窗、汉宁窗等）。

3. 根据窗函数的性质和滤波器的阶数，计算出滤波器的理想频率响应h_ideal。

4. 使用傅里叶变换将理想频率响应转换为时间域的滤波器系数h。

5. 对h进行归一化处理，得到最终的滤波器系数。

4. C语言程序实现下面给出一个简单的C语言程序，实现了FIR滤波器的设计过程。

cinclude <stdio.h>include <math.h>define N 1000 // 输入信号长度define M 50 // 滤波器阶数void fir_filter(float x, float h, float y) {int i, j;for (i = 0; i < N; i++) {y[i] = 0;for (j = 0; j < M; j++) {if (i >= j) {y[i] += h[j] x[i j];}}}}int mn() {float x[N]; // 输入信号float h[M]; // 滤波器系数float y[N]; // 输出信号int i;// 输入信号和滤波器系数for (i = 0; i < N; i++) {x[i] = sin(2 M_PI 1000 i / N) + sin(2 M_PI 2000 i / N); // 两个正弦信号叠加}for (i = 0; i < M; i++) {h[i] = 1.0 / M; // 简单的均值滤波器}// 调用FIR滤波函数fir_filter(x, h, y);// 输出滤波后的信号for (i = 0; i < N; i++) { printf(\。

DSP的FIR设计(低通滤波)C语言编写

一、设计目的低通滤波器设计。

本设计中使用的信号为信息信号： signal=sin(2*pi*sl*n*T)高频噪声1：noise1=0.7*sin(2*pi*ns1*n*T) 高频噪声2：noise2=0.4*sin(2*pi*ns2*n*T) 混合信号： x=(signal+noise1+noise2)其中sl=500Hz ，ns1=3000Hz ，ns2=8000Hz ，T=1/20000。

混合信号波形为滤波器输入信号波形，信息信号波形为输出信号波形，滤波器的效果为滤除两个高频噪声。

二、FIR 滤波器基本理论（1）FIR 滤波器的特点数字滤波器的功能，就是把输入序列通过一定的运算变换成输出序列。

它的实现方法有很多，其中比较常用到的是无限长脉冲响应滤波器 IIR 和有限长脉冲响应滤波器FIR 两种。

在计算量相等的情况下，IIR 数字滤波器比FIR 滤波器的幅频特性优越，频率选择性也好。

但是，它有着致命的缺点，其相位特性不好控制。

它的相位特性)argH( )f(ωωj e =是使频率产生严重的非线性的原因。

但是在图像处理、数据传输等波形传递系统中都越来越多的要求信道具有线性的相位特性。

在这方面 FIR 滤波器具有它独特的优点，设FIR 滤波器单位脉冲响应h(n)长度为N ，其系统函数H(z)为∑-=-=10)()(N n n z n h z HH(z)是1-z 的(N-1)次多项式，它在z 平面上有(N-1)个零点，原点z=0是(N-1)阶重极点。

因此，H(z)永远稳定，它可以在幅度特性随意设计的同时，保证精确、严格的线性相位。

（2）FIR 滤波器的基本结构数字滤波是将输入的信号序列，按规定的算法进行处理，从而得到所期望的输出序列，FIR 滤波器的差分方程为：∑-=-=1)()(N k k k n x a n y对上式进行Z 变换得到FIR 滤波器的传递函数为：()()()∑-=-==10N i kk z b z X z Y z H由上式可以看出，H(z)是1-z 的N-1次多项式，它在z 平面内有N-1个零点，同时在原点处有N-1个重极点。

c语言描述fir

FIR滤波器c语言源程序设计#include <stdio.h>#ifdef WIN32#include <conio.h>#endif#define SAMPLE double /* define the type used for data samples */void clear(int ntaps, SAMPLE z[]){int ii;for (ii = 0; ii < ntaps; ii++) {z[ii] = 0;}}SAMPLE fir_basic(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[]) {int ii;SAMPLE accum;/* store input at the beginning of the delay line */z[0] = input;/* calc FIR */accum = 0;for (ii = 0; ii < ntaps; ii++) {accum += h[ii] * z[ii];}/* shift delay line */for (ii = ntaps - 2; ii >= 0; ii--) {z[ii + 1] = z[ii];}return accum;}SAMPLE fir_circular(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLEz[],int *p_state){int ii, state;SAMPLE accum;state = *p_state; /* copy the filter's state to a local*//* store input at the beginning of the delay line */z[state] = input;if (++state >= ntaps) { /* incr state and check for wrap */state = 0;}/* calc FIR and shift data */accum = 0;for (ii = ntaps - 1; ii >= 0; ii--) {accum += h[ii] * z[state];if (++state >= ntaps) { /* incr state and check for wrap */state = 0;}}*p_state = state; /* return new state to caller */return accum;}SAMPLE fir_shuffle(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[]) {int ii;SAMPLE accum;/* store input at the beginning of the delay line */z[0] = input;/* calc FIR and shift data */accum = h[ntaps - 1] * z[ntaps - 1];for (ii = ntaps - 2; ii >= 0; ii--) {accum += h[ii] * z[ii];z[ii + 1] = z[ii];}return accum;}SAMPLE fir_split(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],int *p_state)int ii, end_ntaps, state = *p_state;SAMPLE accum;SAMPLE const *p_h;SAMPLE *p_z;/* setup the filter */accum = 0;p_h = h;/* calculate the end part */p_z = z + state;*p_z = input;end_ntaps = ntaps - state;for (ii = 0; ii < end_ntaps; ii++) {accum += *p_h++ * *p_z++;}/* calculate the beginning part */p_z = z;for (ii = 0; ii < state; ii++) {accum += *p_h++ * *p_z++;}/* decrement the state, wrapping if below zero */if (--state < 0) {state += ntaps;}*p_state = state; /* return new state to caller */return accum;}SAMPLE fir_double_z(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],int *p_state){SAMPLE accum;int ii, state = *p_state;SAMPLE const *p_h, *p_z;/* store input at the beginning of the delay line as well as ntaps more */z[state] = z[state + ntaps] = input;/* calculate the filter */p_h = h;p_z = z + state;accum = 0;for (ii = 0; ii < ntaps; ii++) {accum += *p_h++ * *p_z++;}/* decrement state, wrapping if below zero */if (--state < 0) {state += ntaps;}*p_state = state; /* return new state to caller */return accum;}SAMPLE fir_double_h(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],int *p_state){SAMPLE accum;int ii, state = *p_state;SAMPLE const *p_h, *p_z;/* store input at the beginning of the delay line */z[state] = input;/* calculate the filter */p_h = h + ntaps - state;p_z = z;accum = 0;for (ii = 0; ii < ntaps; ii++) {accum += *p_h++ * *p_z++;}/* decrement state, wrapping if below zero */if (--state < 0) {state += ntaps;}*p_state = state; /* return new state to caller */return accum;int main(void){#define NTAPS 6static const SAMPLE h[NTAPS] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 }; static SAMPLE h2[2 * NTAPS];static SAMPLE z[2 * NTAPS];#define IMP_SIZE (3 * NTAPS)static SAMPLE imp[IMP_SIZE];SAMPLE output;int ii, state;/* make impulse input signal */clear(IMP_SIZE, imp);imp[5] = 1.0;/* create a SAMPLEd h */for (ii = 0; ii < NTAPS; ii++) {h2[ii] = h2[ii + NTAPS] = h[ii];}/* test FIR algorithms */printf("Testing fir_basic:\n ");clear(NTAPS, z);for (ii = 0; ii < IMP_SIZE; ii++) {output = fir_basic(imp[ii], NTAPS, h, z);printf("%3.1lf ", (double) output);}printf("\n\n");printf("Testing fir_shuffle:\n ");clear(NTAPS, z);state = 0;for (ii = 0; ii < IMP_SIZE; ii++) {output = fir_shuffle(imp[ii], NTAPS, h, z);printf("%3.1lf ", (double) output);}printf("\n\n");printf("Testing fir_circular:\n ");clear(NTAPS, z);state = 0;for (ii = 0; ii < IMP_SIZE; ii++) {output = fir_circular(imp[ii], NTAPS, h, z, &state); printf("%3.1lf ", (double) output);}printf("\n\n");printf("Testing fir_split:\n ");clear(NTAPS, z);state = 0;for (ii = 0; ii < IMP_SIZE; ii++) {output = fir_split(imp[ii], NTAPS, h, z, &state);printf("%3.1lf ", (double) output);}printf("\n\n");printf("Testing fir_double_z:\n ");clear(2 * NTAPS, z);state = 0;for (ii = 0; ii < IMP_SIZE; ii++) {output = fir_double_z(imp[ii], NTAPS, h, z, &state); printf("%3.1lf ", (double) output);}printf("\n\n");printf("Testing fir_double_h:\n ");clear(NTAPS, z);state = 0;for (ii = 0; ii < IMP_SIZE; ii++) {output = fir_double_h(imp[ii], NTAPS, h2, z, &state); printf("%3.1lf ", (double) output);}#ifdef WIN32printf("\n\nHit any key to continue.");getch();#endifreturn 0;}。

DSP的FIR设计(低通滤波)C语言编写解读

一、设计目的低通滤波器设计。

混合信号波形为滤波器输入信号波形，信息信号波形为输出信号波形，滤波器的效果为滤除两个高频噪声。

二、FIR 滤波器基本理论（1）FIR 滤波器的特点数字滤波器的功能，就是把输入序列通过一定的运算变换成输出序列。

它的实现方法有很多，其中比较常用到的是无限长脉冲响应滤波器 IIR 和有限长脉冲响应滤波器FIR 两种。

在计算量相等的情况下，IIR 数字滤波器比FIR 滤波器的幅频特性优越，频率选择性也好。

但是，它有着致命的缺点，其相位特性不好控制。

它的相位特性)argH( )f(ωωj e =是使频率产生严重的非线性的原因。

但是在图像处理、数据传输等波形传递系统中都越来越多的要求信道具有线性的相位特性。

因此，H(z)永远稳定，它可以在幅度特性随意设计的同时，保证精确、严格的线性相位。

（2）FIR 滤波器的基本结构数字滤波是将输入的信号序列，按规定的算法进行处理，从而得到所期望的输出序列，FIR 滤波器的差分方程为：∑-=-=10)()(N k k k n x a n y对上式进行Z 变换得到FIR 滤波器的传递函数为：()()()∑-=-==10N i kk z b z X z Y z H由上式可以看出，H(z)是1-z 的N-1次多项式，它在z 平面内有N-1个零点，同时在原点处有N-1个重极点。

一阶低通滤波c代码

一阶低通滤波c代码以下是一个简单的一阶低通滤波器的C代码实现。

一阶低通滤波器通常用于平滑数据，减少噪声。

它的工作原理是基于前一个输出样本和当前输入样本来计算新的输出样本。

请注意，以下代码假定你已经定义了一个合适的数据类型（如float），并且你的编译器支持基本的数学运算。

c#include <stdio.h>// 定义数据类型typedef float DataType;// 一阶低通滤波器结构体typedef struct {DataType alpha; // 滤波系数，取值范围0到1DataType prevOutput; // 上一次的输出值} FirstOrderLowPassFilter;// 初始化滤波器void initFilter(FirstOrderLowPassFilter *filter, DataType alpha) {filter->alpha = alpha;filter->prevOutput = 0.0;}// 应用滤波器DataType applyFilter(FirstOrderLowPassFilter *filter, DataType input) { DataType output = filter->alpha * input + (1.0 - filter->alpha) * filter->prevOutput;filter->prevOutput = output;return output;}int main() {FirstOrderLowPassFilter filter;DataType input, output;// 初始化滤波器，设置滤波系数为0.1initFilter(&filter, 0.1);// 假设我们有一个输入信号，这里用简单的for循环模拟for (int i = 0; i < 10; i++) {input = (i % 2 == 0) ? 10.0 : 0.0; // 模拟一个方波信号output = applyFilter(&filter, input);printf("Input: %f, Output: %f\n", input, output);}return 0;}以上代码首先定义了一个FirstOrderLowPassFilter结构体，它包含滤波系数alpha 和上一个输出值prevOutput。

fir函数c语言实现

fir函数c语言实现FIR滤波器是一种广泛应用于数字信号处理领域的滤波器，它能够实现无限冲击响应（InfiniteImpulseResponse，简称FIR）滤波。

在许多实际应用中，FIR 滤波器被用来对信号进行平滑处理，去除噪声等。

下面将介绍如何使用C语言实现FIR滤波器。

一、FIR滤波器原理FIR滤波器是一种线性时不变系统，它通过一组滤波器系数将输入信号进行加权叠加，从而实现对信号的滤波处理。

FIR滤波器的输出信号与输入信号的关系可以用冲激响应表示，其冲激响应具有有限长度。

二、C语言实现FIR滤波器以下是一个简单的FIR滤波器的C语言实现，它采用递归方法实现滤波器的计算：```c#include<stdio.h>//FIR滤波器参数定义#defineFIR_LEN6//滤波器长度#defineTARGET_SNR10//目标信噪比#defineALPHA0.001//噪声系数//FIR滤波器系数定义floatfir_coeff[]={/*...*/};//滤波器系数数组//FIR滤波器函数实现floatfir_filter(floatinput){floatoutput=0;//滤波器输出floatx=input;//输入信号当前值floaty=x;//输入信号之前值floatz=x;//滤波器输出之前值inti;for(i=0;i<FIR_LEN;i++){y=y*ALPHA+fir_coeff[i]*z;//更新输入信号和滤波器输出output+=y;//更新滤波器输出z=x;//更新滤波器输出之前值}returnoutput/FIR_LEN;//归一化滤波器输出值}```这个代码实现了简单的FIR滤波器，其输入是一个浮点数类型的信号。

滤波器的长度和参数需要根据具体的应用场景进行调整。

此外，还需要准备一个FIR滤波器系数数组，并将其定义在代码中。

三、使用示例下面是一个使用示例，展示了如何使用上述代码对一组信号进行FIR滤波处理：```c#include<stdio.h>#include<stdlib.h>#include<time.h>intmain(){//生成一组随机信号作为输入数据floatsignals[]={/*...*/};//输入信号数组，包含多个样本数据intsignal_len=sizeof(signals)/sizeof(float);//信号长度srand(time(NULL));//设置随机数种子intidx=rand()%signal_len;//随机选择一个样本作为输入信号的起始点floatoutput[signal_len];//输出数组，用于存储滤波处理后的结果inti;for(i=idx;i<idx+signal_len;i++){//对每个样本进行滤波处理output[i-idx]=fir_filter(signals[i]);//使用fir_filter函数进行滤波处理，并将结果存储在output数组中}printf("Filteredsignals:\n");//输出滤波处理后的结果for(i=0;i<signal_len;i++){//输出每个样本的滤波处理结果printf("%f\n",output[i]);}return0;}```这个示例代码生成了一组随机信号作为输入数据，并使用上述实现的FIR滤波器对每个样本进行滤波处理。

FIR低通滤波器C语言实现

FIR低通滤波器C语言实现下面是一个基于C语言的FIR低通滤波器的实现示例，通过使用FIR 算法对输入信号进行滤波来实现低通滤波的效果。

```c#include <stdio.h>#include <stdlib.h>#define N 1000 // 输入信号长度#define M 51 // FIR滤波器阶数float fir_filter(float x);void generate_input(float input[]);void generate_coefficients(float coefficients[]);int maifloat input[N];float output[N];float coefficients[M];//生成输入信号generate_input(input);//生成滤波器系数generate_coefficients(coefficients);//FIR滤波for (int n = 0; n < N; n++)output[n] = fir_filter(input[n]);}//打印滤波结果for (int n = 0; n < N; n++)printf("%f\n", output[n]);}return 0;//FIR滤波函数float fir_filter(float x)float y = 0;static float shift_register[M] = {0}; // 移位寄存器，用于存储输入序列的历史数据static float coefficients[M] = {0}; // FIR滤波器系数//数据移位for (int i = M - 1; i >= 1; i--)shift_register[i] = shift_register[i - 1];}//输入数据存入移位寄存器shift_register[0] = x;//FIR滤波for (int i = 0; i < M; i++)y += coefficients[i] * shift_register[i];}return y;//生成随机输入信号（仅作示例用）void generate_input(float input[])for (int n = 0; n < N; n++)input[n] = (float)rand( / (float)(RAND_MAX/2) - 1; // 生成范围为[-1, 1)的随机数}//生成低通滤波器系数（仅作示例用）void generate_coefficients(float coefficients[])float cutoff_freq = 0.1; // 截止频率（归一化）for (int i = 0; i < M; i++)if (i == M/2)coefficients[i] = 2 * cutoff_freq; // 滤波器的全通增益} elsecoefficients[i] = sin(2 * M_PI * cutoff_freq * (float)(i - M/2)) / (float)(i - M/2); // 低通滤波系数}}```以上代码实现了一个简单的FIR低通滤波器，主要包含了`fir_filter`函数用于滤波操作，`generate_input`函数用于生成输入信号，`generate_coefficients`函数用于生成滤波器系数。

DSP的FIR设计低通滤波C语言编写

DSP的FIR设计低通滤波C语言编写FIR（有限脉冲响应）滤波器是一种常用的数字滤波器，用于数字信号处理中的滤波操作。

FIR滤波器的设计通常包括两个主要步骤：滤波器的规格化和滤波器系数的计算。

滤波器的规格化是指确定滤波器的采样频率，截止频率以及陷波增益等参数。

在设计低通FIR滤波器时，我们需要确定滤波器的截止频率。

假设我们希望设计一个截止频率为Fs/4的低通FIR滤波器，其中Fs是采样频率。

根据滤波器设计的基本原理，我们可以得到滤波器的频率响应公式为：H(k) = (2 * Fs/4 * sin(2 * pi * Fs/4 * k))/(pi * k)其中，k是从0到N-1的整数序列，N是滤波器的长度。

经过频域设计，我们可以通过计算滤波器的频率响应公式来获得滤波器的系数。

接下来，我们将使用C语言编写一个低通FIR滤波器的代码示例。

在这个示例中，我们将实现一个截止频率为Fs/4的低通FIR滤波器，采样频率为Fs。

代码如下：```c#include <stdio.h>#include <stdlib.h>#include <math.h>//定义滤波器的长度#define N 51//定义采样频率//定义滤波器的截止频率#define Fc (Fs/4)//计算滤波器的系数void calculateCoefficients(float* coefficients)float sum = 0;for (int k = 0; k < N; k++)if (k == N/2)coefficients[k] = 2 * Fc/Fs;} elsecoefficients[k] = (sin(2.0 * M_PI * Fc * (k - N/2) / Fs)) / (M_PI * (k - N/2));}sum += coefficients[k];}//归一化滤波器的系数for (int k = 0; k < N; k++)coefficients[k] /= sum;}//应用滤波器void applyFilter(float* input, float* output, float* coefficients, int length)for (int n = 0; n < length; n++)output[n] = 0;for (int k = 0; k < N; k++)if (n - k >= 0)output[n] += input[n - k] * coefficients[k];}}}int mai//定义输入信号和输出信号的长度int length = 100;//为输入信号和输出信号分配内存空间float* input = (float*)malloc(length*sizeof(float));float* output = (float*)malloc(length*sizeof(float));//为滤波器的系数分配内存空间float* coefficients = (float*)malloc(N*sizeof(float));//生成输入信号for (int n = 0; n < length; n++)input[n] = sin(2.0 * M_PI * 1000 * n / Fs);}//计算滤波器的系数calculateCoefficients(coefficients);//应用滤波器applyFilter(input, output, coefficients, length); //打印输出信号for (int n = 0; n < length; n++)printf("%f\n", output[n]);}//释放内存空间free(input);free(output);free(coefficients);return 0;```在上面的代码示例中，我们首先定义了滤波器的长度、采样频率以及截止频率。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

根据fir滤波器的公式y(n)=∑h(m)x(n-m);(m: 0～(N-1)).利用MATLAB产生滤波器系数（h（n））并归一化，下面为一个LP滤波算法void filter(void){uint16 i,j;fp32 sum;int16 x1[2030];fp32 h[19]={ -0.0027, -0.0025, 0.0050, 0.0157, -0.0000, -0.0471, -0.0482, 0.0838, 0.2953, 0.4013,0.2953, 0.0838, -0.0482, -0.0471, -0.0000,0.0157, 0.0050, -0.0025, -0.0027};for(i=0;i<2020;i++)x1[i] = data0[i];for(i=0;i<2020;i++){sum=0.0;for(j=0;j<19;j++){if(i >= j)sum+=h[j]*x1[i-j];else;}data0[i]=(int16)sum;}for(i=0;i<2000;i++){data0[i] = data0[i+20];}}考虑到前19个点为不完全累加和，故抛去前19个点。

（应该是前后各18个点都是不完全累加和，都应该去掉，对于数据分段进入滤波器的情况，应该把前一段的后面数据放到下一段的前面，这段时间我在解调FSK时遇到了这个问题，通过滤波器的数据的分段处理。

）设输入数据x[N],输出数据y[N],滤波器系数h[n]1.直接法(由y(m)=h(0)*x(m)+h(1)*x(m-1)+...+h(N-1)*x(m-n-1));void fir(short x[], short h[], short y[]){int i,j;long long sum;for (j = 0; j < N; j++){sum = 0;for (i = 0; i < n; i++)sum += x[j-i] * h[i];y[j] = sum >> 15;}}乘法器使用次数：N*n2.逆推法：void fir(short x[], short h[], short y[]){int i,j;long sum;for (j = 0; j < n; j++){for (i = 0; i < N; i++){sum = 0;sum = h[j] * x[i]y[i] += sum >> 15;}}}乘法器使用次数：N*n3.倒序法：（输入输出可以是同一量）void fir(short x[], short h[], short y[]) {int i,j;long long sum;for (j = N; j > 0; j--){sum = 0;for (i = n; i > 0; i--)sum += x[j-i] * h[i];y[j] = sum >> 15;}}#include<stdio.h>#include<math.h>#define true 1#define false 0#define n 8#define bufsize 100 /* the buffer size is 100 *//* global declarations */int in_buffer[bufsize]; /* processing data buffers */int out_buffer[bufsize];/* functions */static int processing(int *input, int *output);static void dataio(void);static long round(long a);void main(){int *input = &in_buffer[0];int *output = &out_buffer[0];puts("the 1st experiment started\n");/* loop forever */while(true){/** read input data using a probe-point connected to a host file.* write output data to a graph connected through a probe-point.*/// read the input signal.// if the input file is sine1.dat, the signal contains 300hz,400hz and 500hz.// if the input file is sine2.dat, the signal contains 100hz,400hz and 500hz.// the sampling frequency is 1200hz.dataio();/* remove the frequency compoment of 400hz and 500hz*/processing(input, output);// write the output signal.// the output file is result.dat.dataio();}}/** ======== processing ========** function: apply a low-pass fir filter to input signal and remove the frequency higher than 350hz.** parameters: address of input and output buffers.** return value: true.static int processing(int *input, int *output){int i,size = bufsize;short xx0,x,y;// short z[n]={0,0,0,0,0,0,0,0,0};short z[n]={0,0,0,0,0,0,0,0};//short w[2*n+1]={22,356,155,990,466,220,777,216,777,26,466,9,155,0,22};//short w[2*n+1]={6,457,56,1024,224,418,523,382,784,99,784,43,523};// shortw[2*n+1]={330*2,3299*2,1982*2,6867*2,4955*2,1594*2,6607*2,1065*2,4955*2,109*2,1982*2,17*2, 330*2};//short w[2*n+1]={661,6598,3964,13733,9910,3187,13214,2131,9910,217,3964,34,661};// shortw[2*n+1]={58,5628,526,8192,2105,5883,4913,3829,7369,1543,7369,504,4913,102,2105,14,526,1,5 8};//shortw[2*n+1]={28,4432,280,8192,1259,4883,3356,3975,5873,1509,7048,644,5873,142,3356,30,1259,3, 280,0,28};// short w[2*n+1]={26,651,182,1024,545,421,909,247,909,51,545,11,182,1,26};//shortw[2*n+1]={831,20846,5815,32768,17445,13486,29075,7888,29075,1647,17445,349,5815,21,831}; //short w[2*n+1]={208,5211,1454,8192,4361,3371,7269,1972,7269,412,4361,87,1454,5,208};short w[2*n+1]={101,4356,810,8192,2835,3403,5670,2517,7088,605,5670,193,2835,21,810}; // shortw[2*n+1]={101,4356,810,8192,2835,3403,5670,2517,7088,605,5670,193,2835,21,810,2,101};// shortw[2*n+1]={50,3814,454,8192,1815,3504,4235*,3084,6353,831,6353,349,4235,50,1815,8,454,0,50} ;long y0,z0;//22222222222222while(size--){xx0=*input++;x=xx0*6;z0=(long)x<<15;y0=0;for(i=0;i<n;i++){z0-=(long)w[2*i+1]*(long)z[i];y0+=(long)w[2*i+2]*(long)z[i];}y0+=(long)w[0]*(z0>>15);y0=round(y0);for(i=n-1;i>0;i--)z[i]=z[i-1];z0=round(z0);z[0]=(short)(z0>>15);y=(short)(y0>>15);*output++ =y;}/* additional processing load */return(true);/** ======== dataio ========** function: read input signal and write processed output signal. ** parameters: none.** return value: none.*/static void dataio(){/* do data i/o */return;}static long round(long a){long x3;x3=a&(0xffff0000);return x3;}。