test_cfft_rad4_ns_nbrev.c

ADI BF DSP的FFT汇编优化后的代码

/*******************************************************************************
Copyright(c) 2000 - 2002 Analog Devices. All Rights Reserved.
Developed by Joint Development Software Application Team, IPDC, Bangalore, India
for Blackfin DSPs  ( Micro Signal Architecture 1.0 specification).

By using this module you agree to the terms of the Analog Devices License
Agreement for DSP Software. 
********************************************************************************
File Name       : Test_CFFT_Rad4_NS_NBRev.c
Description     : This function tests _CFFT_Rad4_NS_NBRev with 5 test cases 
                    and finds cycle count for 
                    FFT sizes of 16, 64, 256 and 1024.
                    1. Test1 - DC Test for               64 point FFT
                    2. Test2 - Impulse Test for          64 point FFT
                    3. Test3 - Multifrequency Test for   64 point FFT  
                    4. Test4 - Multifrequency Test for 1024 point FFT  
                    5. Test5 - Random Data Test for      16 point FFT  

                    Note : This one supplies the inputs in normal order without 
                    scaling, i.e., Non-Scaled Non-Bit-Reveresed(NS_NBRev)
*******************************************************************************/
#include "CFFT_Rad4_data.h"
#include "FFT_Rad4_Twiddle_Factors.h"

extern void _CFFT_Rad4_NS_NBRev(complex_fract16 in[], complex_fract16 out[], 
                                int N, complex_fract16 w[]); 

void (*f1)();
int error_flag = 0;
int cycle_count[10];

main(void)
    {
    int n, i;
    int error1,error2;

    f1 = (void(*)()) _CFFT_Rad4_NS_NBRev;// Function Pointer

// TEST 1:-  DC Test for 64 points
// Finds radix4 DIT FFT for 64 points with DC input,i.e all the inputs are same.
// Only y(0) will be present.

    n = 64;
    for(i = 0; i < n; i++)
    {
       (in[i].re) = const_data1;
       (in[i].im) = zero_in;
    }
    
    for(i = 0; i < 3*n/4-2; i++)
    {
       (w[i].re) = twid64[2*i];
       (w[i].im) = twid64[2*i + 1];
    }

    cycle_count[0] = Compute_Cycle_Count(in, output, n, w);
                            //This function inturn calls CFFT_Rad4_NS_NBRev()

    error1 = output[0].re - const_data1;
    error2 = output[0].im;
    error1 = (error1<0) ? -error1 : error1;
    error2 = (error2<0) ? -error2 : error2;    

    if((error1 > MAX_PERMISSIBLE_ERROR) || (error2 > MAX_PERMISSIBLE_ERROR)) 
        error_flag = error_flag | 1;

    for(i=1; i<n; i++)
    {
        error1 = output[i].re;
        error2 = output[i].im;
        error1 = (error1<0) ? -error1 : error1;
        error2 = (error2<0) ? -error2 : error2;
        if((error1 > MAX_PERMISSIBLE_ERROR) || (error2 > MAX_PERMISSIBLE_ERROR))
        {
            error_flag = error_flag | 1;
        }
    }


// TEST 2:-  Impulse test for 64 points
// Finds radix4 DIT FFT for 64 points with input as impulse
// The output bins are verified for their constant value(flat spectrum)


    n = 64;
    in[0].re = const_data1;
    in[0].im = zero_in;

    for(i = 1; i<n; i++)
    {
       (in[i].re) = zero_in;
       (in[i].im) = zero_in;
    }

    for(i = 0; i<3*n/4-2; i++)
    {
       (w[i].re) = twid64[2*i];
       (w[i].im) = twid64[2*i+1];
    }
    
    cycle_count[1] = Compute_Cycle_Count(in, output, n, w);
                            //This function inturn calls CFFT_Rad4_NS_NBRev()
    for(i=0; i<n; i++)
    {
        error1 = output[i].re - 0x200;
        error2 = output[i].im - zero_in;
        error1 = (error1<0) ? -error1 : error1;
        error2 = (error2<0) ? -error2 : error2;

        if((error1 > MAX_PERMISSIBLE_ERROR) || (error2 > MAX_PERMISSIBLE_ERROR)) 
        {
            error_flag = error_flag | 2;
        }
    }

// TEST 3:-  Multifrequency test for 64 points
// Finds radix4 DIT FFT for 64 points with input as average of two sinewaves 
// generated using MATLAB and then compares each FFT output with that generated 
// using MATLAB

    n = 64;
    for(i = 0; i<n; i++)
    {
       (in[i].re) = in_64[i];
       (in[i].im) = zero_in;
    }
    for(i = 0; i<3*n/4-2; i++)
    {
       (w[i].re) = twid64[2*i];
       (w[i].im) = twid64[2*i+1];
    }
    
    cycle_count[2] = Compute_Cycle_Count(in, output, n, w);
                            //This function inturn calls CFFT_Rad4_NS_NBRev()
    error1 = 0;                 
    error2 = 0;

    for(i=0; i<n; i++)
    {
        if ( (i == 12) || (i == 16) )
        {
            error1 = output[i].re - zero_in;
            error2 = output[i].im + 0x2000;
            error1 = (error1<0) ? -error1 : error1;
            error2 = (error2<0) ? -error2 : error2;
            if((error1 > MAX_PERMISSIBLE_ERROR) || (error2 > MAX_PERMISSIBLE_ERROR)) 
            {
                error_flag = error_flag | 4;
            }
        }
        else if ( (i == 48) || (i == 52) )
        {
            error1 = output[i].re - 0;
            error2 = output[i].im - 0x2000;
            error1 = (error1<0) ? -error1 : error1;
            error2 = (error2<0) ? -error2 : error2;
            if((error1 > MAX_PERMISSIBLE_ERROR) 
            || (error2 > MAX_PERMISSIBLE_ERROR)) 
                {
                    error_flag = error_flag | 4;
                }
        }
        else
        {
            error1 = output[i].re - 0;
            error2 = output[i].im - 0;
            error1 = (error1<0) ? -error1 : error1;
            error2 = (error2<0) ? -error2 : error2;
            if((error1 > MAX_PERMISSIBLE_ERROR) 
            || (error2 > MAX_PERMISSIBLE_ERROR)) 
            {
                error_flag = error_flag | 4;
            }
        }
    }
    
// TEST 4:-  Multifrequency test for 1024 points
// Finds radix4 DIT FFT for 1024 points with input as average of two sine waves 
// generated using MATLAB and then compares each FFT output with that generated 
// using MATLAB

    n = 1024;   
    for(i = 0; i < n; i++)
    {
       (in[i].re) = in_1024[i];
       (in[i].im) = zero_in;
    }

    for(i = 0; i < 3 * n/4 - 2; i++)
    {
       (w[i].re) = twid1024[2*i];
       (w[i].im) = twid1024[2*i + 1];
    }

    cycle_count[3] = Compute_Cycle_Count(in, output, n, w);
                            //This function inturn calls CFFT_Rad4_NS_NBRev()
    error1 = 0;                 
    error2 = 0;

    for(i = 0; i < n; i++)
    {
        if ( (i == 64) || (i == 128) )
        {
            error1 = output[i].re - 0;
            error2 = output[i].im + 0x2000;
            error1 = (error1<0) ? -error1 : error1;
            error2 = (error2<0) ? -error2 : error2;
            if((error1 > MAX_PERMISSIBLE_ERROR) 
            || (error2 > MAX_PERMISSIBLE_ERROR)) 
            {
                error_flag = error_flag | 8;
            }
        }
        else if ( (i == 896) || (i == 960) )
        {
            error1 = output[i].re - 0;
            error2 = output[i].im - 0x2000;
            error1 = (error1<0) ? -error1 : error1;
            error2 = (error2<0) ? -error2 : error2;
            if((error1 > MAX_PERMISSIBLE_ERROR) 
            || (error2 > MAX_PERMISSIBLE_ERROR)) 
            {
                error_flag = error_flag | 8;
            }
        }
        else
        {
            error1 = output[i].re - 0;
            error2 = output[i].im - 0;
            error1 = (error1<0) ? -error1 : error1;
            error2 = (error2<0) ? -error2 : error2;
            if((error1 > MAX_PERMISSIBLE_ERROR) 
            || (error2 > MAX_PERMISSIBLE_ERROR)) 
            {
                error_flag = error_flag | 8;
            }
        }
    }
    
// TEST 5:-  Finds radix4 DIT FFT for 16 points with random input generated 
// using MATLAB and then compares each FFT output with that generated using 
// MATLAB
    n = 16;
    for(i = 0; i < n; i++)
    {
       (in[i].re) = in_16_real[i];
       (in[i].im) = in_16_imag[i];
    }
    
    for(i = 0; i < 3*n/4 - 2; i++)
    {
       (w[i].re) = twid16[2*i];
       (w[i].im) = twid16[2*i+1];
    }

    cycle_count[4] = Compute_Cycle_Count(in, output, n, w);
                            //This function inturn calls CFFT_Rad4_NS_NBRev()
    for(i=0; i<n; i++)
    {
        error1 = output[i].re - out_16_real[i];
        error2 = output[i].im - out_16_imag[i];
        error1 = (error1<0) ? -error1 : error1;
        error2 = (error2<0) ? -error2 : error2;
        if((error1 > MAX_PERMISSIBLE_ERROR) || (error2 > MAX_PERMISSIBLE_ERROR))
        {
            error_flag = error_flag | 16;
        }
    }
    #ifdef PRINTF_SUPPORT
        if(error_flag & 1)
            printf("Test Case 1 failed\n");
        else
            printf("Test Case 1 passed\n");
        if(error_flag & 2)
            printf("Test Case 2 failed\n");
        else
            printf("Test Case 2 passed\n");
        if(error_flag & 4)
            printf("Test Case 3 failed\n");
        else
            printf("Test Case 3 passed\n");
        if(error_flag & 8)
            printf("Test Case 4 failed\n");
        else
            printf("Test Case 4 passed\n");
        if(error_flag & 16)
            printf("Test Case 5 failed\n");
        else
            printf("Test Case 5 passed\n");
    #endif

}