dsp_bitrev_cplx.h

来自「dm642函数库」· C头文件 代码 · 共 202 行 · 第 1/2 页

/* ======================================================================== */
/*  TEXAS INSTRUMENTS, INC.                                                 */
/*                                                                          */
/*  DSPLIB  DSP Signal Processing Library                                   */
/*                                                                          */
/*      Release:        Revision 1.04b                                      */
/*      CVS Revision:   1.6     Sun Sep 29 03:31: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                                                                    */
/*      DSP_bitrev_cplx                                                     */
/*                                                                          */
/*  REVISION DATE                                                           */
/*      18-Sep-2001                                                         */
/*                                                                          */
/*  USAGE                                                                   */
/*      This routine is C Callable and can be called as:                    */
/*                                                                          */
/*      void DSP_bitrev_cplx(int *x, short *index, int nx);                 */
/*                                                                          */
/*      x[nx]  : Complex input array to be bit-reversed. One element        */
/*               consists of a pair of 16-bit data.                         */
/*      index[]: Array of size ~sqrt(nx) created by the routine             */
/*               bitrev_index to allow the fast implementation of the       */
/*               bit-reversal.                                              */
/*      nx     : Number of elements in array x[]. Must be power of 2.       */
/*                                                                          */
/*  DESCRIPTION                                                             */
/*      This routine performs the bit-reversal of the input array x[],      */
/*      where x[] is an integer array of length nx containing 16-bit        */
/*      complex pairs of data.  This routine requires the index array       */
/*      provided by the program below.  This index should be generated at   */
/*      compile time not by the DSP.                                        */
/*                                                                          */
/*      authorizes the use of the bit-reversal code and related table       */
/*      generation code with TMS320-family DSPs manufactured by TI.         */
/*                                                                          */
/*      // ----------------------------------------------------------- //   */
/*      //  This routine calculates the index for bit reversal of      //   */
/*      //  an array of length nx.  The length of the index table is   //   */
/*      //  2^(2*ceil(k/2)) where nx = 2^k.                            //   */
/*      //                                                             //   */
/*      //  In other words, the length of the index table is:          //   */
/*      //      - for even power of radix: sqrt(nx)                    //   */
/*      //      - for odd  power of radix: sqrt(2*nx)                  //   */
/*      // ----------------------------------------------------------- //   */
/*      void bitrev_index(short *index, int nx)                             */
/*      {                                                                   */
/*          int   i, j, k, radix = 2;                                       */
/*          short nbits, nbot, ntop, ndiff, n2, raddiv2;                    */
/*                                                                          */
/*          nbits = 0;                                                      */
/*          i = nx;                                                         */
/*          while (i > 1)                                                   */
/*          {                                                               */
/*              i = i >> 1;                                                 */
/*              nbits++;                                                    */
/*          }                                                               */
/*                                                                          */
/*          raddiv2 = radix >> 1;                                           */
/*          nbot    = nbits >> raddiv2;                                     */
/*          nbot    = nbot << raddiv2 - 1;                                  */
/*          ndiff   = nbits & raddiv2;                                      */
/*          ntop    = nbot + ndiff;                                         */
/*          n2      = 1 << ntop;                                            */
/*                                                                          */
/*          index[0] = 0;                                                   */
/*          for ( i = 1, j = n2/radix + 1; i < n2 - 1; i++)                 */
/*          {                                                               */
/*              index[i] = j - 1;                                           */
/*                                                                          */
/*              for (k = n2/radix; k*(radix-1) < j; k /= radix)             */
/*                  j -= k*(radix-1);                                       */
/*                                                                          */
/*              j += k;                                                     */
/*          }                                                               */
/*          index[n2 - 1] = n2 - 1;                                         */
/*      }                                                                   */