tw_radix2.c

来自「dm642函数库」· C语言 代码 · 共 258 行

/* ======================================================================== */
/*  TEXAS INSTRUMENTS, INC.                                                 */
/*                                                                          */
/*  NAME                                                                    */
/*      tw_radix2                                                           */
/*                                                                          */
/*  USAGE                                                                   */
/*      This is a stand-alone program intended to generate twiddle-factor   */
/*      arrays for the DSP_radix2 FFT library routine.  It is called as     */
/*      follows:                                                            */
/*                                                                          */
/*          tw_radix2 [-s scale] N > outputfile.c                           */
/*                                                                          */
/*      The argument 'N' specifies the size of the FFT.  This value         */
/*      must be a power of 2.  The switch '-s scale' allows selecting       */
/*      a different scale factor for the coefficients.  The default         */
/*      scale factor is 32767.5.                                            */
/*                                                                          */
/*      This program will generate the twiddle factor array 'w' and         */
/*      output the result to the display.  Redirect the output to           */
/*      a file as shown above.                                              */
/*                                                                          */
/*  DESCRIPTION                                                             */
/*      This program contains the twiddle-factor generation routine         */
/*      that is described within the source code for the DSPLIB             */
/*      FFT function DSP_radix2.  It does not produce appropriate           */
/*      twiddle-factor arrays for the other FFT implementations.            */
/*                                                                          */
/*      Please consult the specific FFT that you are using for details.     */
/*                                                                          */
/*      The final twiddle-factor array generated by the routine will        */
/*      be 2 * N elements long.                                             */
/*                                                                          */
/*  NOTES                                                                   */
/*      The code below may be adapted to run directly on the target,        */
/*      rather than running as a separate program running off-line.         */
/*      Such adaptation is not recommended for time-critical applications.  */
/*      To adapt this program, remove the 'usage' and 'main' functions,     */
/*      and call 'gen_twiddle' directly.                                    */
/*                                                                          */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2001 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#ifndef PI
# ifdef M_PI
#  define PI M_PI
# else
#  define PI 3.14159265358979323846
# endif
#endif

/* ======================================================================== */
/*  D2S -- Truncate a 'double' to a 'short', with clamping.                 */
/* ======================================================================== */
static short d2s(double d)
{
    if (d >=  32767.0) return  32767;
    if (d <= -32768.0) return -32768;
    return (short)d;
}

/* ======================================================================== */
/*  GEN_TWIDDLE -- Generate twiddle factors for TI's custom FFTs.           */
/*                                                                          */
/*  USAGE                                                                   */
/*      This routine is called as follows:                                  */
/*                                                                          */
/*          int gen_twiddle(short *w, int n, double scale)                  */
/*                                                                          */
/*          short  *w     Pointer to twiddle-factor array                   */
/*          int    n      Size of FFT                                       */
/*          double scale  Scale factor to apply to values.                  */
/*                                                                          */
/*      The routine will generate the twiddle-factors directly into the     */
/*      array you specify.  The array needs to be N elements long.          */
/* ======================================================================== */
int gen_twiddle(short *w, int n, double scale)
{
    double angle, step;
    int i;

    step = (2.0 * PI) / (double)n;
    for (i = 0, angle = 0.0; i < n; i += 2, angle += step)
    {
        w[i + 0] = d2s(scale * -cos(angle));
        w[i + 1] = d2s(scale * -sin(angle));
    }

    return n;
}

/* ======================================================================== */
/*  USAGE -- Print usage information and optionally an error message.       */
/* ======================================================================== */
void usage(char *error)
{
    fprintf(stderr,
"                                                                        \n"
"USAGE                                                                   \n"
"    This is a stand-alone program intended to generate twiddle-factor   \n"
"    arrays for the DSP_radix2 library routine.  It is called as follows:\n"
"                                                                        \n"
"        tw_radix2 [-s scale] N > outputfile.c                           \n"
"                                                                        \n"
"    The argument 'N' specifies the size of the FFT.  This value         \n"
"    must be a power of 2.  The switch '-s scale' allows selecting       \n"
"    a different scale factor for the coefficients.  The default         \n"
"    scale factor is 32767.5.                                            \n"
"                                                                        \n"
"    This program will generate the twiddle factor array 'w' and         \n"
"    output the result to the display.  Redirect the output to           \n"
"    a file as shown above.                                              \n"
"                                                                        \n");

    if (error)
        fprintf(stderr, "ERROR:  %s\n", error);

    exit(1);
}


/* ======================================================================== */
/*  MAIN -- Where the action happens.                                       */
/* ======================================================================== */
int main(int argc, char *argv[])
{
    int i, n = -1, size;
    int is_pow_4 = 0;
    short *w;
    double scale = 32767.5;
    char *s;
    char buf[80];

    /* -------------------------------------------------------------------- */
    /*  Parse the arguments.                                                */
    /* -------------------------------------------------------------------- */
    if (argc < 2) { usage(NULL); }

    while (argc-->1)
    {
        if (**++argv == '-' || **argv == '/')
        {
            switch (argv[0][1])
            {
                case 's' : case 'S' :
                {
                    if (argv[0][2])
                    {
                        s = &argv[0][2];
                    } else
                    {
                        argc--;
                        s = *++argv;
                    }
                    if (!s || !*s || sscanf(s, "%lf", &scale) != 1)
                        usage("The -s switch requires a numeric argument.\n");

                    if (scale <= 0.0 || scale >  32767.6)
                        usage("Scale factor out of range.\n");

                    break;
                }

                default:
                {
                    sprintf(buf, "Unrecognized switch character: '%c'\n",
                            argv[0][1]);
                    usage(buf);
                    break;
                }
            }
        } else
        {
            if (!isdigit(argv[0][0]) || sscanf(argv[0], "%d", &n) != 1)
            {
                sprintf(buf, "Unrecognized argument:  %-.32s\n",
                        argv[0][0]);
                usage(buf);
            }

            if (n < 16 || n > 32768)
                usage("FFT size must be between 16 and 32768 points.");

            for (i = 2; i < 24; i++)
                if ((1 << i) == n) break;

            is_pow_4 = !(i & 1);

            if (i >= 24)
            {
                usage("FFT size must be a power of 2\n");
                exit(1);
            }
        }
    }

    if (n == -1)
        usage("Must specify FFT size.");

    /* -------------------------------------------------------------------- */
    /*  Allocate memory for the FFT twiddle factors.                        */
    /* -------------------------------------------------------------------- */
    w = calloc(2 * sizeof(short), n);
    if (!w)
    {
        fprintf(stderr, "ERROR:  Unable to allocate memory for "
                        "twiddle factors\n");
        exit(1);
    }


    /* -------------------------------------------------------------------- */
    /*  Generate the twiddle-factor array.                                  */
    /* -------------------------------------------------------------------- */
    size = gen_twiddle(w, n, scale);


    /* -------------------------------------------------------------------- */
    /*  Print out the resulting twiddle factors.                            */
    /* -------------------------------------------------------------------- */

    printf(
"/* -------------------------------------------------------------------- */\n"
"/*  Automatically generated twiddle-factor array.                       */\n"
"/*      Number of points:    %-5d                                      */\n"
"/*      Scale factor:        %-20.9f                       */\n"
"/*      Appropriate FFTs:    DSP_radix2                                 */\n"
"/*      Required alignment:  4 byte (word)                              */\n"
"/* -------------------------------------------------------------------- */\n"
"/*  NOTE:  It is suggested that this array be aligned in a different    */\n"
"/*  starting bank than the actual FFT data, to reduce bank conflicts.   */\n"
"/*  This can be achieved by using the DATA_MEM_BANK pragma.  Please     */\n"
"/*  see the TMS320C6000 Optimizing C Compiler Reference (SPRU187E)      */\n"
"/*  for details on \"#pragma DATA_MEM_BANK\".                             */\n"
"/* -------------------------------------------------------------------- */\n"
"\n"
"#pragma DATA_ALIGN(w, 4);  /* Remove this if using DATA_MEM_BANK */\n"
"\n", n, scale);

    printf("const short w[2 * %d] =\n{", size / 2);
    for (i = 0; i < size; i++)
    {
        printf("%s%c0x%.4X",
               i == 0 ? "\n    " : (i & 7) == 0 ? ",\n    " : ", ",
               w[i] < 0 ? '-' : ' ', abs(w[i]));
    }
    printf("\n};\n");

    return 0;
}