dsp_bitrev_cplx.h64

来自「dm642函数库」· H64 代码 · 共 199 行 · 第 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;                                         *