test_cr2fftn_outplace.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_cr2fftn_outplace.c
Description     : This function tests _cr2fftn_outplace with 6 test cases and 
                  finds cycle count for FFT sizes of 16, 64, 256 and 1024.
                    1. Test1 - Zero Length FFT
                    2. Test2 - Zero input FFT for        32 point FFT 
                    3. Test3 - DC Test for               32 point FFT
                    4. Test4 - Impulse Test for          32 point FFT
                    5. Test5 - Multifrequency Test for   32 point FFT  
                    6. Test6 - Multifrequency Test for 1024 point FFT  
*******************************************************************************/
#include "tcr2fftn_outplace.h"

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

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

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

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

    for(i=0; i<512; i++)
    {
        w[i].re = twid1024[2*i];
        w[i].im = twid1024[2*i+1];
    }

// TEST 1:-  Zero length test

    n = 0;
    wst = 0;
    for(i=0; i<FFTSIZE; i++)
    {
        in[i].re = 700*i;
        in[i].im = -850*i;
        out[i].re =zero_in , out[i].im = zero_in;
    }

    cycle_count[0] = Compute_Cycle_Count(in, out, w, wst, n);
                            //This function inturn calls cr2fftn_outplace()

    for (i = 0; i < FFTSIZE; i++)
    {
        if ((out[i].re != 0) || (out[i].im != 0))
        {    
            error_flag = error_flag | 1;
        }
    }

// TEST 2:-  Zero input FFT for 32 points

    n = FFTSIZE;
    wst = 32;
    for(i=0; i<n; i++)
    {
        in[i].re = zero_in;
        in[i].im = zero_in;
        out[i].re =zero_in, out[i].im = zero_in;
    }

    cycle_count[1] = Compute_Cycle_Count(in, out, w, wst, n);
                            //This function inturn calls cr2fftn_outplace()

    for (i = 0; i < n; i++)
    {
        if ((out[i].re != 0) || (out[i].im != 0))
        {    
            error_flag = error_flag | 2;
        }
    }

// TEST 3:-  DC test FFT for 32 points

    n = FFTSIZE;
    wst = 32;
    for(i=0; i<n; i++)
    {
        in[i].re = const_data1;
        in[i].im = const_data1;
        out[i].re =zero_in, out[i].im = zero_in;
    }

    cycle_count[2] = Compute_Cycle_Count(in, out, w, wst, n);
                            //This function inturn calls cr2fftn_outplace()

    error1 = out[0].re - const_data1;
    error2 = out[0].im - const_data1;
    if(abs(error1) >1 || abs (error2) > 1)
    {
        error_flag = error_flag | 4;
    }
    for (i = 1; i < n; i++)
    {
        if ((out[i].re != 0) || (out[i].im != 0))
        {    
            error_flag = error_flag | 4;
        }
    }

// TEST 4:-  Impulse test for 32 point FFT

    n = FFTSIZE;
    wst = 32;
    in[0].re = const_data1;
    in[0].im = const_data1;
    for(i=1; i<n; i++)
    {
        in[i].re = zero_in;
        in[i].im = zero_in;
    }

    cycle_count[3] = Compute_Cycle_Count(in, out, w, wst, n);
                            //This function inturn calls cr2fftn_outplace()

    for (i = 0; i < n; i++)
    {
        error1 = 512 - out[i].re;
        error2 = 512 - out[i].im;
        if (abs(error1) >1 || abs(error2) > 1)
        {    
            error_flag = error_flag | 8;
        }
    }

// TEST 5:-  Multifrequency test for 32 points

    n = FFTSIZE;
    wst = 32;
    for(i=0; i<n; i++)
    {
        in[i].re = multi_in[i].re;
        in[i].im = multi_in[i].im;
    }

    cycle_count[4] = Compute_Cycle_Count(in, out, w, wst, n);
                            //This function inturn calls cr2fftn_outplace()
    error1 = out[0].re - 0;
    error2 = out[0].im - 0;

    if(abs(error1) >1 || abs (error2) > 1)
    {
        error_flag = error_flag | 16;
    }
    error1 = out[1].re - 0;
    error2 = out[1].im - 0xF000;
    if(abs(error1) >1 || abs (error2) > 1)
    {
        error_flag = error_flag | 16;
    }
    error1 = out[2].re - 0x1000;
    error2 = out[2].im - 0;
    if(abs(error1) >1 || abs (error2) > 1)
    {
        error_flag = error_flag | 16;
    }
    for(i=3; i< 30; i++)
    {
        error1 = out[i].re - 0;
        error2 = out[i].im - 0;
        if(abs(error1) >1 || abs (error2) > 1)
        {
            error_flag = error_flag | 16;
        }
    }
    error1 = out[30].re - 0x1000;
    error2 = out[30].im - 0;
    if(abs(error1) >1 || abs (error2) > 1)
    {
        error_flag = error_flag | 16;
    }
    error1 = out[31].re - 0;
    error2 = out[31].im - 0x1000;
    if(abs(error1) >1 || abs (error2) > 1)
    {
        error_flag = error_flag | 16;
    }

// TEST 6:-  Multifrequency test for 1024 points

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

    cycle_count[5] = Compute_Cycle_Count(in, out, w, wst, n);
                            //This function inturn calls cr2fftn_outplace()
    error1 = 0;                 
    error2 = 0;
    for(i = 0; i < n; i++)
    {
        if ( (i == 64) || (i == 128) )
        {
            error1 = out[i].re - 0;
            error2 = out[i].im + 0x1000;
            error1 = (error1<0) ? -error1 : error1;
            error2 = (error2<0) ? -error2 : error2;
            if((error1 > MAX_PERMISSIBLE_ERROR) 
            || (error2 > MAX_PERMISSIBLE_ERROR)) 
                {
                    error_flag = error_flag | 32;
                }
        }
        else if ( (i == 896) || (i == 960) )
        {
            error1 = out[i].re - 0;
            error2 = out[i].im - 0x1000;
            error1 = (error1<0) ? -error1 : error1;
            error2 = (error2<0) ? -error2 : error2;
            if((error1 > MAX_PERMISSIBLE_ERROR) 
            || (error2 > MAX_PERMISSIBLE_ERROR)) 
                {
                    error_flag = error_flag | 32;
                }
        }
        else
        {
            error1 = out[i].re - 0;
            error2 = out[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 | 32;
                }
        }
    }
    #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");
        if(error_flag & 32)
            printf("Test Case 6 failed\n");
        else
            printf("Test Case 6 passed\n");
    #endif
}