/* ======================================================================== */ /* TEXAS INSTRUMENTS, INC. */ /* */ /* DSPLIB DSP Signal Processing Library */ /* */ /* Release: Version 1.02 */ /* CVS Revision: 1.4 Tue Feb 26 13:35:28 2002 (UTC) */ /* Snapshot date: 18-Apr-2002 */ /* */ /* 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) 2002 Texas Instruments, Incorporated. */ /* All Rights Reserved. */ /* ======================================================================== */ /* ======================================================================== */ /* 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] : Input array to be bit-reversed. */ /* index[]: Array of size ~sqrt(nx) created by the routine */ /* bitrev_index to allow the fast implementation of the */ /* bit-reversal. */ /* nx : Number of points in array x[]. Must be power of 2. */ /* */ /* DESCRIPTION */ /* This routine performs the bit-reversal of the input array x[]. */ /* where x[] is an array of length nx 16-bit complex pairs of data. */ /* This requires the index array provided by the program below. This */ /* index should be generated at compile time not by the DSP. The code */ /* is given below. */ /* */ /* 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 n. The length of the index table is // */ /* // 2^(2*ceil(k/2)) where n = 2^k. // */ /* // // */ /* // In other words, the length of the index table is: // */ /* // // */ /* // Even power Odd Power // */ /* // of radix of radix // */ /* // sqrt(n) sqrt(2*n) // */ /* // // */ /* // ----------------------------------------------------------- // */ /* void bitrev_index(short *index, int n) */ /* { */ /* int i, j, k, radix = 2; */ /* short nbits, nbot, ntop, ndiff, n2, raddiv2; */ /* */ /* nbits = 0; */ /* i = n; */ /* 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; */ /* } */ /* */ /* C CODE */ /* void bitrev(int *x, short *index, int nx) */ /* { */ /* int i; */ /* short i0, i1, i2, i3; */ /* short j0, j1, j2, j3; */ /* int xi0, xi1, xi2, xi3; */ /* int xj0, xj1, xj2, xj3; */ /* short t; */ /* int a, b, ia, ib, ibs; */ /* int mask; */ /* int nbits, nbot, ntop, ndiff, n2, halfn; */ /* short *xs = (short *) x; */ /* */ /* nbits = 0; */ /* i = nx; */ /* while (i > 1) */ /* { */ /* i = i >> 1; */ /* nbits++; */ /* } */ /* */ /* nbot = nbits >> 1; */ /* ndiff = nbits & 1; */ /* ntop = nbot + ndiff; */ /* n2 = 1 << ntop; */ /* mask = n2 - 1; */ /* halfn = nx >> 1; */ /* */ /* for (i0 = 0; i0 < halfn; i0 += 2) */ /* { */ /* b = i0 & mask; */ /* a = i0 >> nbot; */ /* if (!b) ia = index[a]; */ /* ib = index[b]; */ /* ibs = ib << nbot; */ /* */ /* j0 = ibs + ia; */ /* t = i0 < j0; */ /* xi0 = x[i0]; */ /* xj0 = x[j0]; */ /* */ /* if (t){x[i0] = xj0; */ /* x[j0] = xi0;} */ /* */ /* i1 = i0 + 1; */ /* j1 = j0 + halfn; */ /* xi1 = x[i1]; */ /* xj1 = x[j1]; */ /* x[i1] = xj1; */ /* x[j1] = xi1; */ /* */ /* i3 = i1 + halfn; */ /* j3 = j1 + 1; */ /* xi3 = x[i3]; */ /* xj3 = x[j3]; */ /* if (t){x[i3] = xj3; */ /* x[j3] = xi3;} */ /* } */ /* } */ /* */ /* ASSUMPTIONS */ /* nx must be a power of 2. */ /* The table from bitrev_index is already created. */ /* LITTLE ENDIAN configuration used. */ /* */ /* NOTES */ /* If N <= 4K one can use the char (8-bit) data type for */ /* the "index" variable. This would require changing the LDH when */ /* loading index values in the assembly routine to LDB. This would */ /* further reduce the size of the Index Table by half its size. */ /* */ /* This code is interrupt tolerant, but not interruptible. */ /* */ /* CYCLES */ /* (N/4 + 2) * 7 + 18 */ /* */ /* e.g. N = 256, cycles = 480 */ /* */ /* CODESIZE */ /* 352 bytes */ /* */ /* ------------------------------------------------------------------------ */ /* Copyright (c) 2002 Texas Instruments, Incorporated. */ /* All Rights Reserved. */ /* ======================================================================== */ #ifndef DSP_BITREV_CPLX_H_ #define DSP_BITREV_CPLX_H_ 1 void DSP_bitrev_cplx(int *x, short *index, int nx); #endif /* ======================================================================== */ /* End of file: dsp_bitrev_cplx.h */ /* ------------------------------------------------------------------------ */ /* Copyright (c) 2002 Texas Instruments, Incorporated. */ /* All Rights Reserved. */ /* ======================================================================== */