dsp_fft16x16t.h
来自「dm642函数库」· C头文件 代码 · 共 374 行 · 第 1/2 页
H
374 行
/* ======================================================================== */
/* TEXAS INSTRUMENTS, INC. */
/* */
/* DSPLIB DSP Signal Processing Library */
/* */
/* Release: Revision 1.04b */
/* CVS Revision: 1.7 Sun Sep 29 03:32:21 2002 (UTC) */
/* Snapshot date: 23-Oct-2003 */
/* */
/* This library contains proprietary intellectual property of Texas */
/* Instruments, Inc. The library and its source code are protected by */
/* various copyrights, and portions may also be protected by patents or */
/* other legal protections. */
/* */
/* This software is licensed for use with Texas Instruments TMS320 */
/* family DSPs. This license was provided to you prior to installing */
/* the software. You may review this license by consulting the file */
/* TI_license.PDF which accompanies the files in this library. */
/* ------------------------------------------------------------------------ */
/* Copyright (C) 2003 Texas Instruments, Incorporated. */
/* All Rights Reserved. */
/* ======================================================================== */
/* ======================================================================== */
/* Assembler compatibility shim for assembling 4.30 and later code on */
/* tools prior to 4.30. */
/* ======================================================================== */
/* ======================================================================== */
/* End of assembler compatibility shim. */
/* ======================================================================== */
/* ======================================================================== */
/* TEXAS INSTRUMENTS, INC. */
/* */
/* NAME */
/* fft: Mixed radix FFT for 2^M and 4^M, 16x16 with truncation */
/* */
/* */
/* REVISION DATE */
/* 23-May-2002 */
/* */
/* USAGE */
/* This routine is C-callable and can be called as: */
/* */
/* void DSP_fft16x16t(const short * ptr_w, int npoints, short * ptr_x, */
/* short * ptr_y) */
/* */
/* where: */
/* ptr_w: pointer to an array of twiddle factors generated as explained */
/* below. */
/* npoints: Number of points for the FFT transform, can be a multiple of */
/* 2 or 4. */
/* ptr_x: Pointer to input data to be transformed. */
/* ptr_y: Pointer that contains the final FFT results in normal order. */
/* */
/* DESCRIPTION */
/* This code performs a mixed radix FFT with digit reversal. The code */
/* uses a special ordering of twiddle factors and memory accesses */
/* to improve performance in the presence of cache. It operates */
/* largely in-place, but the final digit-reversed output is written */
/* out-of-place. */
/* */
/* This code requires a special sequence of twiddle factors stored */
/* in Q.15 fixed-point format. The following C code illustrates */
/* one way to generate the desired twiddle-factor array: */
/* */
/* #include <math.h> */
/* */
/* #ifndef PI */
/* # define PI (3.14159265358979323846) */
/* #endif */
/* */
/* short d2s(double d) */
/* { */
/* d = floor(0.5 + d); // Explicit rounding to integer // */
/* if (d >= 32767.0) return 32767; */
/* if (d <= -32768.0) return -32768; */
/* return (short)d; */
/* } */
/* */
/* void gen_twiddle(short *w, int n) */
/* { */
/* double M = 32767.5; */
/* int i, j, k; */
/* */
/* for (j = 1, k = 0; j < n >> 2; j = j << 2) */
/* { */
/* for (i = 0; i < n >> 2; i += j << 1) */
/* { */
/* w[k + 11] = d2s(M * cos(6.0 * PI * (i + j) / n)); */
/* w[k + 10] = d2s(M * sin(6.0 * PI * (i + j) / n)); */
/* w[k + 9] = d2s(M * cos(6.0 * PI * (i ) / n)); */
/* w[k + 8] = d2s(M * sin(6.0 * PI * (i ) / n)); */
/* */
/* w[k + 7] = d2s(M * cos(4.0 * PI * (i + j) / n)); */
/* w[k + 6] = d2s(M * sin(4.0 * PI * (i + j) / n)); */
/* w[k + 5] = d2s(M * cos(4.0 * PI * (i ) / n)); */
/* w[k + 4] = d2s(M * sin(4.0 * PI * (i ) / n)); */
/* */
/* w[k + 3] = d2s(M * cos(2.0 * PI * (i + j) / n)); */
/* w[k + 2] = d2s(M * sin(2.0 * PI * (i + j) / n)); */
/* w[k + 1] = d2s(M * cos(2.0 * PI * (i ) / n)); */
/* w[k + 0] = d2s(M * sin(2.0 * PI * (i ) / n)); */
/* */
/* k += 12; */
/* } */
/* } */
/* w[2*n - 1] = w[2*n - 3] = w[2*n - 5] = 32767; */
/* w[2*n - 2] = w[2*n - 4] = w[2*n - 6] = 0; */
/* } */
/* */
/* ASSUMPTIONS */
/* The size of the FFT, n, must be a power of 4 or 2 and greater than */
/* or equal to 16 and less than 32768. */
/* */
/* The arrays 'x[]', 'y[]', and 'w[]' all must be aligned on a */
/* double-word boundary for the "optimized" implementations. */
/* */
/* The input and output data are complex, with the real/imaginary */
/* components stored in adjacent locations in the array. The real */
/* components are stored at even array indices, and the imaginary */
/* components are stored at odd array indices. */
/* */
/* TECHNIQUES */
/* The following C code represents an implementation of the Cooley */
/* Tukey radix 4 DIF FFT. It accepts the inputs in normal order and */
/* produces the outputs in digit reversed order. The natural C code */
/* shown in this file on the other hand, accepts the inputs in nor- */
/* mal order and produces the outputs in normal order. */
/* */
/* Several transformations have been applied to the original Cooley */
/* Tukey code to produce the natural C code description shown here. */
/* In order to understand these it would first be educational to */
/* understand some of the issues involved in the conventional Cooley */
/* Tukey FFT code. */
/* */
/* void radix4(int n, short x[], short wn[]) */
/* { */
/* int n1, n2, ie, ia1, ia2, ia3; */
/* int i0, i1, i2, i3, i, j, k; */
/* short co1, co2, co3, si1, si2, si3; */
/* short xt0, yt0, xt1, yt1, xt2, yt2; */
/* short xh0, xh1, xh20, xh21, xl0, xl1,xl20,xl21; */
/* */
/* n2 = n; */
/* ie = 1; */
/* for (k = n; k > 1; k >>= 2) */
/* { */
/* n1 = n2; */
/* n2 >>= 2; */
/* ia1 = 0; */
/* */
/* for (j = 0; j < n2; j++) */
/* { */
/* ia2 = ia1 + ia1; */
/* ia3 = ia2 + ia1; */
/* */
/* co1 = wn[2 * ia1 ]; */
/* si1 = wn[2 * ia1 + 1]; */
/* co2 = wn[2 * ia2 ]; */
/* si2 = wn[2 * ia2 + 1]; */
/* co3 = wn[2 * ia3 ]; */
/* si3 = wn[2 * ia3 + 1]; */
/* ia1 = ia1 + ie; */
/* */
/* for (i0 = j; i0< n; i0 += n1) */
/* { */
/* i1 = i0 + n2; */
/* i2 = i1 + n2; */
/* i3 = i2 + n2; */
/* */
/* */
/* xh0 = x[2 * i0 ] + x[2 * i2 ]; */
/* xh1 = x[2 * i0 + 1] + x[2 * i2 + 1]; */
/* xl0 = x[2 * i0 ] - x[2 * i2 ]; */
/* xl1 = x[2 * i0 + 1] - x[2 * i2 + 1]; */
/* */
/* xh20 = x[2 * i1 ] + x[2 * i3 ]; */
/* xh21 = x[2 * i1 + 1] + x[2 * i3 + 1]; */
/* xl20 = x[2 * i1 ] - x[2 * i3 ]; */
/* xl21 = x[2 * i1 + 1] - x[2 * i3 + 1]; */
/* */
/* x[2 * i0 ] = xh0 + xh20; */
/* x[2 * i0 + 1] = xh1 + xh21; */
/* */
/* xt0 = xh0 - xh20; */
/* yt0 = xh1 - xh21; */
/* xt1 = xl0 + xl21; */
/* yt2 = xl1 + xl20; */
⌨️ 快捷键说明
复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?