float RunOneForwardTest(int fft_log_size, int signal_type, float signal_value,
struct SnrResult* snr) {
OMX_FC32* x;
OMX_FC32* y;
struct AlignedPtr* x_aligned;
struct AlignedPtr* y_aligned;
OMX_FC32* y_true;
OMX_INT n, fft_spec_buffer_size;
OMXResult status;
OMXFFTSpec_C_FC32 * fft_fwd_spec = NULL;
int fft_size;
fft_size = 1 << fft_log_size;
status = omxSP_FFTGetBufSize_C_FC32(fft_log_size, &fft_spec_buffer_size);
if (verbose > 63) {
printf("fft_spec_buffer_size = %d\n", fft_spec_buffer_size);
}
fft_fwd_spec = (OMXFFTSpec_C_FC32*) malloc(fft_spec_buffer_size);
status = omxSP_FFTInit_C_FC32(fft_fwd_spec, fft_log_size);
if (status) {
fprintf(stderr,
"Failed to init forward FFT: status = %d, order %d \n",
status, fft_log_size);
exit(1);
}
x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size);
y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2));
y_true = (OMX_FC32*) malloc(sizeof(*y_true) * fft_size);
x = x_aligned->aligned_pointer_;
y = y_aligned->aligned_pointer_;
GenerateSignal(x, y_true, fft_size, signal_type, signal_value);
if (verbose > 255) {
printf("&x = %p\n", (void*) x);
printf("&y = %p\n", (void*) y);
printf("&buffer = %p\n", (void*) ((ARMsFFTSpec_R_FC32*)fft_fwd_spec)->pBuf);
}
if (verbose > 63) {
printf("Signal\n");
DumpArrayComplexFloat("x", fft_size, x);
printf("Expected FFT output\n");
DumpArrayComplexFloat("y", fft_size, y_true);
}
status = ForwardFFT(x, y, fft_fwd_spec);
if (status) {
fprintf(stderr, "Forward FFT failed: status = %d\n", status);
exit(1);
}
if (verbose > 63) {
printf("FFT Output\n");
DumpArrayComplexFloat("y", fft_size, y);
}
CompareComplexFloat(snr, y, y_true, fft_size);
FreeAlignedPointer(x_aligned);
FreeAlignedPointer(y_aligned);
free(fft_fwd_spec);
return snr->complex_snr_;
}
float RunOneInverseTest(int fft_log_size, int signal_type, float signal_value,
struct SnrResult* snr) {
OMX_FC32* x;
OMX_FC32* y;
OMX_FC32* z;
struct AlignedPtr* x_aligned;
struct AlignedPtr* y_aligned;
struct AlignedPtr* z_aligned;
OMX_INT n, fft_spec_buffer_size;
OMXResult status;
OMXFFTSpec_C_FC32 * fft_fwd_spec = NULL;
OMXFFTSpec_C_FC32 * fft_inv_spec = NULL;
int fft_size;
fft_size = 1 << fft_log_size;
status = omxSP_FFTGetBufSize_C_FC32(fft_log_size, &fft_spec_buffer_size);
if (verbose > 3) {
printf("fft_spec_buffer_size = %d\n", fft_spec_buffer_size);
}
fft_inv_spec = (OMXFFTSpec_C_FC32*)malloc(fft_spec_buffer_size);
status = omxSP_FFTInit_C_FC32(fft_inv_spec, fft_log_size);
if (status) {
fprintf(stderr, "Failed to init backward FFT: status = %d, order %d\n",
status, fft_log_size);
exit(1);
}
x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size);
y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2));
z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size);
x = x_aligned->aligned_pointer_;
y = y_aligned->aligned_pointer_;
z = z_aligned->aligned_pointer_;
GenerateSignal(x, y, fft_size, signal_type, signal_value);
if (verbose > 63) {
printf("Inverse FFT Input Signal\n");
DumpArrayComplexFloat("x", fft_size, y);
printf("Expected Inverse FFT output\n");
DumpArrayComplexFloat("x", fft_size, x);
}
status = InverseFFT(y, z, fft_inv_spec);
if (status) {
fprintf(stderr, "Inverse FFT failed: status = %d\n", status);
exit(1);
}
if (verbose > 63) {
printf("Actual Inverse FFT Output\n");
DumpArrayComplexFloat("z", fft_size, z);
}
CompareComplexFloat(snr, z, x, fft_size);
FreeAlignedPointer(x_aligned);
FreeAlignedPointer(y_aligned);
FreeAlignedPointer(z_aligned);
free(fft_inv_spec);
return snr->complex_snr_;
}
void TimeOneFloatFFT(int count, int fft_log_size, float signal_value,
int signal_type) {
struct AlignedPtr* x_aligned;
struct AlignedPtr* y_aligned;
struct AlignedPtr* z_aligned;
struct AlignedPtr* y_true_aligned;
struct ComplexFloat* x;
struct ComplexFloat* y;
OMX_FC32* z;
struct ComplexFloat* y_true;
OMX_INT n, fft_spec_buffer_size;
OMXFFTSpec_C_FC32 * fft_fwd_spec = NULL;
OMXFFTSpec_C_FC32 * fft_inv_spec = NULL;
int fft_size;
struct timeval start_time;
struct timeval end_time;
double elapsed_time;
struct SnrResult snr_forward;
struct SnrResult snr_inverse;
fft_size = 1 << fft_log_size;
x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size);
y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2));
z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size);
y_true_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size);
x = x_aligned->aligned_pointer_;
y = y_aligned->aligned_pointer_;
z = z_aligned->aligned_pointer_;
y_true = y_true_aligned->aligned_pointer_;
GenerateTestSignalAndFFT(x, y_true, fft_size, signal_type, signal_value, 0);
omxSP_FFTGetBufSize_C_FC32(fft_log_size, &fft_spec_buffer_size);
fft_fwd_spec = (OMXFFTSpec_C_FC32*) malloc(fft_spec_buffer_size);
fft_inv_spec = (OMXFFTSpec_C_FC32*) malloc(fft_spec_buffer_size);
omxSP_FFTInit_C_FC32(fft_fwd_spec, fft_log_size);
omxSP_FFTInit_C_FC32(fft_inv_spec, fft_log_size);
if (do_forward_test) {
GetUserTime(&start_time);
for (n = 0; n < count; ++n) {
FORWARD_FLOAT_FFT((OMX_FC32*) x, (OMX_FC32*) y, fft_fwd_spec);
}
GetUserTime(&end_time);
elapsed_time = TimeDifference(&start_time, &end_time);
CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size);
PrintResult("Forward Float FFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_);
}
if (do_inverse_test) {
GetUserTime(&start_time);
for (n = 0; n < count; ++n) {
INVERSE_FLOAT_FFT((OMX_FC32*) y_true, z, fft_inv_spec);
}
GetUserTime(&end_time);
elapsed_time = TimeDifference(&start_time, &end_time);
CompareComplexFloat(&snr_inverse, (OMX_FC32*) z, (OMX_FC32*) x, fft_size);
PrintResult("Inverse Float FFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_);
}
FreeAlignedPointer(x_aligned);
FreeAlignedPointer(y_aligned);
FreeAlignedPointer(z_aligned);
FreeAlignedPointer(y_true_aligned);
free(fft_fwd_spec);
free(fft_inv_spec);
}
