void GenerateSignal(OMX_SC32* x, OMX_SC32* fft, int size, int signal_type) {
int k;
struct ComplexFloat *test_signal;
struct ComplexFloat *true_fft;
test_signal = (struct ComplexFloat*) malloc(sizeof(*test_signal) * size);
true_fft = (struct ComplexFloat*) malloc(sizeof(*true_fft) * size);
GenerateTestSignalAndFFT(test_signal, true_fft, size, signal_type,
signal_value, 0);
/*
* Convert the complex float result to SC32 format. Just round.
* No error-checking here!
*/
for (k = 0; k < size; ++k) {
x[k].Re = 0.5 + test_signal[k].Re;
x[k].Im = 0.5 + test_signal[k].Im;
fft[k].Re = 0.5 + true_fft[k].Re;
fft[k].Im = 0.5 + true_fft[k].Im;
}
free(test_signal);
free(true_fft);
}
/*
* Generate a signal and the corresponding theoretical FFT
*/
void GenerateSignal(OMX_F32* x, OMX_FC32* fft, int size, int signal_type,
float signal_value) {
int k;
struct ComplexFloat *test_signal;
struct ComplexFloat *true_fft;
test_signal = (struct ComplexFloat*) malloc(sizeof(*test_signal) * size);
true_fft = (struct ComplexFloat*) malloc(sizeof(*true_fft) * size);
GenerateTestSignalAndFFT(test_signal, true_fft, size, signal_type,
signal_value, 1);
/*
* Convert the complex result to what we want
*/
for (k = 0; k < size; ++k) {
x[k] = test_signal[k].Re;
}
for (k = 0; k < size / 2 + 1; ++k) {
fft[k].Re = true_fft[k].Re;
fft[k].Im = true_fft[k].Im;
}
free(test_signal);
free(true_fft);
}
void generateSC16Signal(OMX_SC16* x, OMX_SC16* fft, int size, int signal_type,
float signal_value) {
int k;
struct ComplexFloat *test_signal;
struct ComplexFloat *true_fft;
test_signal = (struct ComplexFloat*) malloc(sizeof(*test_signal) * size);
true_fft = (struct ComplexFloat*) malloc(sizeof(*true_fft) * size);
GenerateTestSignalAndFFT(test_signal, true_fft, size, signal_type,
signal_value, 0);
/*
* Convert the complex result to what we want
*/
for (k = 0; k < size; ++k) {
x[k].Re = 0.5 + test_signal[k].Re;
x[k].Im = 0.5 + test_signal[k].Im;
fft[k].Re = 0.5 + true_fft[k].Re;
fft[k].Im = 0.5 + true_fft[k].Im;
}
free(test_signal);
free(true_fft);
}
void GenerateSignal(OMX_FC32* x, OMX_FC32* fft, int size, int signal_type,
float signal_value) {
GenerateTestSignalAndFFT((struct ComplexFloat *) x,
(struct ComplexFloat *) fft,
size,
signal_type,
signal_value,
0);
}
void TimeOneNE10FFT(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 ComplexFloat* x;
struct ComplexFloat* y;
OMX_FC32* z;
struct ComplexFloat* y_true;
int n;
ne10_result_t status;
ne10_fft_cfg_float32_t fft_fwd_spec;
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) * 2 * fft_size);
z_aligned = AllocAlignedPointer(32, sizeof(*z) * 2 * fft_size);
y_true = (struct ComplexFloat*) malloc(sizeof(*y_true) * fft_size);
x = x_aligned->aligned_pointer_;
y = y_aligned->aligned_pointer_;
z = z_aligned->aligned_pointer_;
GenerateTestSignalAndFFT(x, y_true, fft_size, signal_type, signal_value, 0);
fft_fwd_spec = ne10_fft_alloc_c2c_float32(fft_size);
if (!fft_fwd_spec) {
fprintf(stderr, "NE10 FFT: Cannot initialize FFT structure for order %d\n", fft_log_size);
return;
}
if (do_forward_test) {
GetUserTime(&start_time);
for (n = 0; n < count; ++n) {
ne10_fft_c2c_1d_float32_neon((ne10_fft_cpx_float32_t *) y,
(ne10_fft_cpx_float32_t *) x,
fft_fwd_spec,
0);
}
GetUserTime(&end_time);
elapsed_time = TimeDifference(&start_time, &end_time);
CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size);
PrintResult("Forward NE10 FFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_);
if (verbose >= 255) {
printf("Input data:\n");
DumpArrayComplexFloat("x", fft_size, (OMX_FC32*) x);
printf("FFT Actual:\n");
DumpArrayComplexFloat("y", fft_size, (OMX_FC32*) y);
printf("FFT Expected:\n");
DumpArrayComplexFloat("true", fft_size, (OMX_FC32*) y_true);
}
}
if (do_inverse_test) {
GetUserTime(&start_time);
for (n = 0; n < count; ++n) {
ne10_fft_c2c_1d_float32_neon((ne10_fft_cpx_float32_t *) z,
(ne10_fft_cpx_float32_t *) y_true,
fft_fwd_spec,
1);
}
GetUserTime(&end_time);
elapsed_time = TimeDifference(&start_time, &end_time);
CompareComplexFloat(&snr_inverse, (OMX_FC32*) z, (OMX_FC32*) x, fft_size);
PrintResult("Inverse NE10 FFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_);
if (verbose >= 255) {
printf("Input data:\n");
DumpArrayComplexFloat("y", fft_size, (OMX_FC32*) y_true);
printf("IFFT Actual:\n");
DumpArrayComplexFloat("z", fft_size, z);
printf("IFFT Expected:\n");
DumpArrayComplexFloat("x", fft_size, (OMX_FC32*) x);
}
}
ne10_fft_destroy_c2c_float32(fft_fwd_spec);
FreeAlignedPointer(x_aligned);
FreeAlignedPointer(y_aligned);
FreeAlignedPointer(z_aligned);
free(y_true);
}
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);
}
void TimeOnePfFFT(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;
int n;
int fft_size;
struct timeval start_time;
struct timeval end_time;
double elapsed_time;
PFFFT_Setup *s;
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(*y_true) * fft_size);
x = x_aligned->aligned_pointer_;
y = y_aligned->aligned_pointer_;
z = z_aligned->aligned_pointer_;
y_true = y_true_aligned->aligned_pointer_;
s = pffft_new_setup(fft_size, PFFFT_COMPLEX);
if (!s) {
fprintf(stderr, "TimeOnePfFFT: Could not initialize structure for order %d\n",
fft_log_size);
}
GenerateTestSignalAndFFT(x, y_true, fft_size, signal_type, signal_value, 0);
if (do_forward_test) {
GetUserTime(&start_time);
for (n = 0; n < count; ++n) {
pffft_transform_ordered(s, (float*)x, (float*)y, NULL, PFFFT_FORWARD);
}
GetUserTime(&end_time);
elapsed_time = TimeDifference(&start_time, &end_time);
CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size);
PrintResult("Forward PFFFT FFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_);
if (verbose >= 255) {
printf("FFT Actual:\n");
DumpArrayComplexFloat("y", fft_size, (OMX_FC32*) y);
printf("FFT Expected:\n");
DumpArrayComplexFloat("true", fft_size, (OMX_FC32*) y_true);
}
}
if (do_inverse_test) {
float scale = 1.0 / fft_size;
memcpy(y, y_true, sizeof(*y) * (fft_size + 2));
GetUserTime(&start_time);
for (n = 0; n < count; ++n) {
int m;
pffft_transform_ordered(s, (float*)y_true, (float*)z, NULL, PFFFT_BACKWARD);
/*
* Need to include cost of scaling the inverse
*/
ScaleVector((OMX_F32*) z, 2 * fft_size, fft_size);
}
GetUserTime(&end_time);
elapsed_time = TimeDifference(&start_time, &end_time);
CompareComplexFloat(&snr_inverse, (OMX_FC32*) z, (OMX_FC32*) x, fft_size);
PrintResult("Inverse PFFFT FFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_);
if (verbose >= 255) {
printf("IFFT Actual:\n");
DumpArrayComplexFloat("z", fft_size, z);
printf("IFFT Expected:\n");
DumpArrayComplexFloat("x", fft_size, (OMX_FC32*) x);
}
}
FreeAlignedPointer(x_aligned);
FreeAlignedPointer(y_aligned);
FreeAlignedPointer(z_aligned);
FreeAlignedPointer(y_true_aligned);
pffft_destroy_setup(s);
}