tcfftrad2x2_scaled.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   : tcfftrad2x2_scaled.c
Desciption  : This module tests _cfftrad2x2_scaled() function.
*******************************************************************************/
#define FFT_SIZE 16
#include<stdio.h>
#include"twid_4.h"
#include"twid_8.h"
#include"twid_16.h"
#include "sinusoid8x8.h"
#include "rand8x8.h"
#include "rand4x4.h"

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

void _cfftrad2x2_scaled();

main()
{
    int i,j, error1, error2, N;

    f1 = _cfftrad2x2_scaled;
        
// Test Case 1 : Input is a 2D DC signal  

    N = FFT_SIZE;
    for(i=0;i<FFT_SIZE;i++)
    {
        w[i].re = twid16_real[i];       // 8 x 8 twiddle factor initialization
        w[i].im = twid16_imag[i];
    }

    for(i=0;i<N*N;i++)
    {
        _in[i].re = const_data1/4;
        _in[i].im = zero_in;
    }

    cycle_count[0] = Compute_Cycle_Count(_in, _out, w, N);
                            //This function inturn calls cfftrad2x2_scaled()

    error1 = _out[0].re - const_data1;
    error2 = _out[0].im;
    if(error1 < 0) error1 = -error1;
    if(error2 < 0) error2 = -error2;
    if(error1 > MAX_PERMISSIBLE_ERROR || error2 > MAX_PERMISSIBLE_ERROR)
    {
            error_flag = error_flag | 1;
    }
    for(i=1;i<N*N;i++)
    {
        error1 = _out[i].re;
        error2 = _out[i].im;
        if(error1 < 0) error1 = -error1;
        if(error2 < 0) error2 = -error2;
        if(error1 > MAX_PERMISSIBLE_ERROR || error2 > MAX_PERMISSIBLE_ERROR)
        {
            error_flag = error_flag | 1;
            break;
        }
    }

//Test Case 2 : Input is a 2D impulse    
    N = FFT_SIZE;

    _in[0].re = const_data1/4;
    _in[0].im = zero_in;
    for(i=1;i<N*N;i++)
    {
        _in[i].re = zero_in;
        _in[i].im = zero_in;
    }

  cycle_count[1] = Compute_Cycle_Count(_in, _out, w, N);
                             //This function inturn calls cfftrad2x2_scaled()

    for(i=0;i<N*N;i++)
    {
        error1 = _out[i].re - const_data1/(N*N);
        error2 = _out[i].im;
        if(error1 < 0) error1 = -error1;
        if(error2 < 0) error2 = -error2;
        if(error1 > MAX_PERMISSIBLE_ERROR || error2 > MAX_PERMISSIBLE_ERROR)
        {
            error_flag = error_flag | 2;
            break;
        }
    }

//Test Case 3 : Input is real signal (A 2D sinusoid)

    N = 16;
    for(i=0;i<N*N;i++)
    {
        _in[i].re = in_sin[i]/4;
        _in[i].im = zero_in;
        exp[i].re = outsin_real[i];
        exp[i].im = outsin_imag[i];
    }
    
  cycle_count[2] = Compute_Cycle_Count(_in, _out, w, N);
                             //This function inturn calls cfftrad2x2_scaled()

    for(i=0;i<N*N;i++)
    {
        error1 = _out[i].re - outsin_real[i];
        error2 = _out[i].im - outsin_imag[i];
        if(error1 < 0) error1 = -error1;
        if(error2 < 0) error2 = -error2;
        if(error1 > MAX_PERMISSIBLE_ERROR || error2 > MAX_PERMISSIBLE_ERROR)
        {
            error_flag = error_flag | 4;
            break;
        }
    }

//Test Case 4 : Input is random 2D signal
    
    N = 8;
    for(i=0;i<N*N;i++)
    {
        _in[i].re = inrand_real[i]/4;
        _in[i].im = inrand_imag[i]/4;
        exp[i].re = outrand_real[i];
        exp[i].im = outrand_imag[i];
    }

    for(i=0;i<N;i++)
    {
        w[i].re = twid8_real[i];
        w[i].im = twid8_imag[i];
    }

  cycle_count[3] = Compute_Cycle_Count(_in, _out, w, N);
                              //This function inturn calls cfftrad2x2_scaled()

    for(i=0;i<N*N;i++)
    {
        error1 = _out[i].re - outrand_real[i];
        error2 = _out[i].im - outrand_imag[i];
        if(error1 < 0) error1 = -error1;
        if(error2 < 0) error2 = -error2;
        if(error1 > MAX_PERMISSIBLE_ERROR || error2 > MAX_PERMISSIBLE_ERROR)
        {
            error_flag = error_flag | 8;
            break;
        }
    }

//Test Case 5 : Input is random 2D signal
    
    N = 4;
    for(i=0;i<N*N;i++)
    {
        _in[i].re = inrand4_real[i]/4;
        _in[i].im = inrand4_imag[i]/4;
        exp[i].re = outrand4_real[i];
        exp[i].im = outrand4_imag[i];
    }

    for(i=0;i<N;i++)
    {
        w[i].re = twid4_real[i];
        w[i].im = twid4_imag[i];
    }

    cycle_count[4] = Compute_Cycle_Count(_in, _out, w, N);
                                //This function inturn calls cfftrad2x2_scaled()

    for(i=0;i<N*N;i++)
    {
        error1 = _out[i].re - outrand4_real[i];
        error2 = _out[i].im - outrand4_imag[i];
        if(error1 < 0) error1 = -error1;
        if(error2 < 0) error2 = -error2;
        if(error1 > MAX_PERMISSIBLE_ERROR || error2 > MAX_PERMISSIBLE_ERROR)
        {
            error_flag = error_flag | 16;
            break;
        }
    }
    #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

}