1728 lines
73 KiB
C
1728 lines
73 KiB
C
#include "system/includes.h"
|
||
#include "app_config.h"
|
||
#include "fftvec_math_drv.h"
|
||
#include "_kiss_fft_guts.h"
|
||
|
||
|
||
#if defined CONFIG_ASR_ALGORITHM || defined CONFIG_REVERB_MODE_ENABLE || defined CONFIG_AEC_ENC_ENABLE || defined CONFIG_DNS_ENC_ENABLE || defined CONFIG_M4A_DEC_ENABLE || defined CONFIG_NEW_M4A_DEC_ENABLE || defined CONFIG_AAC_DEC_ENABLE || defined CONFIG_WMA_DEC_ENABLE || defined CONFIG_SPECTRUM_FFT_EFFECT_ENABLE
|
||
|
||
static DEFINE_SPINLOCK(fft_lock);
|
||
|
||
#define FFT_REAL 1 //complex
|
||
#define IFFT_DIV2 (3-FFT_REAL)
|
||
#define FFT_ISR_IE 0
|
||
|
||
//软件fft算法
|
||
/* #define KISS_FFT */
|
||
|
||
#define SHR(a,shift) ((a) >> (shift))
|
||
|
||
#define PSHR(a,shift) ((a)>=0?(SHR((a)+(1<<(shift-1)),shift)):\
|
||
(SHR((a)+(1<<(shift-1))-1,shift)))
|
||
|
||
#if defined CONFIG_WMA_DEC_ENABLE
|
||
#define MAX_FFT_SUPPORT_POINT_NUM 2048
|
||
#else
|
||
#define MAX_FFT_SUPPORT_POINT_NUM 1024
|
||
#endif
|
||
|
||
#if defined CONFIG_CPU_WL82 && defined CONFIG_ASR_ALGORITHM
|
||
sec(.fft_data) static int datain[MAX_FFT_SUPPORT_POINT_NUM];
|
||
sec(.fft_data) static int datain_y[MAX_FFT_SUPPORT_POINT_NUM];
|
||
sec(.fft_data) static int dataout[MAX_FFT_SUPPORT_POINT_NUM + 2];
|
||
#else
|
||
#if defined CONFIG_VIDEO_ENABLE
|
||
sec(.fft_data) static int datain[MAX_FFT_SUPPORT_POINT_NUM + 2];
|
||
sec(.fft_data) static int *dataout = datain;
|
||
sec(.fft_data) static int datain_y[0];
|
||
#else
|
||
sec(.fft_data) static int datain[MAX_FFT_SUPPORT_POINT_NUM];
|
||
sec(.fft_data) static int dataout[MAX_FFT_SUPPORT_POINT_NUM + 2];
|
||
sec(.fft_data) static int datain_y[0];
|
||
#endif
|
||
#endif
|
||
|
||
typedef struct fft_config_dat {
|
||
unsigned long fft0_con;
|
||
unsigned long fft0_iadr;
|
||
unsigned long fft0_oadr;
|
||
unsigned long fft0_null;
|
||
} fft_config_struct;
|
||
|
||
sec(.fft_data) static fft_config_struct fft_config;
|
||
sec(.fft_data) static hwvec_ctx_t g_vector_core_set;
|
||
|
||
static const struct {
|
||
u32 block;
|
||
u32 config;
|
||
} complex_tab[] = {
|
||
{ 128, COMPLEX_FFT128_CONFIG },
|
||
{ 128, COMPLEX_IFFT128_CONFIG },
|
||
{ 256, COMPLEX_FFT256_CONFIG },
|
||
{ 256, COMPLEX_IFFT256_CONFIG },
|
||
{ 512, COMPLEX_FFT512_CONFIG },
|
||
{ 512, COMPLEX_IFFT512_CONFIG },
|
||
{ 1024, COMPLEX_FFT1024_CONFIG },
|
||
{ 1024, COMPLEX_IFFT1024_CONFIG},
|
||
{ 2048, COMPLEX_FFT2048_CONFIG },
|
||
{ 2048, COMPLEX_IFFT2048_CONFIG},
|
||
{ 10, COMPLEX_FFT10_CONFIG },
|
||
{ 10, COMPLEX_IFFT10_CONFIG },
|
||
{ 15, COMPLEX_FFT15_CONFIG },
|
||
{ 15, COMPLEX_IFFT15_CONFIG },
|
||
{ 20, COMPLEX_FFT20_CONFIG },
|
||
{ 20, COMPLEX_IFFT20_CONFIG },
|
||
{ 30, COMPLEX_FFT30_CONFIG },
|
||
{ 30, COMPLEX_IFFT30_CONFIG },
|
||
{ 32, COMPLEX_FFT32_CONFIG },
|
||
{ 32, COMPLEX_IFFT32_CONFIG },
|
||
{ 40, COMPLEX_FFT40_CONFIG },
|
||
{ 40, COMPLEX_IFFT40_CONFIG },
|
||
{ 60, COMPLEX_FFT60_CONFIG },
|
||
{ 60, COMPLEX_IFFT60_CONFIG },
|
||
{ 64, COMPLEX_FFT64_CONFIG },
|
||
{ 64, COMPLEX_IFFT64_CONFIG },
|
||
{ 80, COMPLEX_FFT80_CONFIG },
|
||
{ 80, COMPLEX_IFFT80_CONFIG },
|
||
{ 120, COMPLEX_FFT120_CONFIG },
|
||
{ 120, COMPLEX_IFFT120_CONFIG },
|
||
{ 160, COMPLEX_FFT160_CONFIG },
|
||
{ 160, COMPLEX_IFFT160_CONFIG },
|
||
{ 240, COMPLEX_FFT240_CONFIG },
|
||
{ 240, COMPLEX_IFFT240_CONFIG },
|
||
{ 320, COMPLEX_FFT320_CONFIG },
|
||
{ 320, COMPLEX_IFFT320_CONFIG },
|
||
{ 480, COMPLEX_FFT480_CONFIG },
|
||
{ 480, COMPLEX_IFFT480_CONFIG },
|
||
{ 960, COMPLEX_FFT960_CONFIG },
|
||
{ 960, COMPLEX_IFFT960_CONFIG },
|
||
};
|
||
|
||
static const struct {
|
||
u32 block;
|
||
u32 config;
|
||
} real_tab[] = {
|
||
{ 128, REAL_FFT128_CONFIG },
|
||
{ 128, REAL_IFFT128_CONFIG },
|
||
{ 256, REAL_FFT256_CONFIG },
|
||
{ 256, REAL_IFFT256_CONFIG },
|
||
{ 512, REAL_FFT512_CONFIG },
|
||
{ 512, REAL_IFFT512_CONFIG },
|
||
{ 1024, REAL_FFT1024_CONFIG },
|
||
{ 1024, REAL_IFFT1024_CONFIG},
|
||
{ 2048, REAL_FFT2048_CONFIG },
|
||
{ 2048, REAL_IFFT2048_CONFIG},
|
||
{ 20, REAL_FFT20_CONFIG },
|
||
{ 20, REAL_IFFT20_CONFIG },
|
||
{ 30, REAL_FFT30_CONFIG },
|
||
{ 30, REAL_IFFT30_CONFIG },
|
||
{ 40, REAL_FFT40_CONFIG },
|
||
{ 40, REAL_IFFT40_CONFIG },
|
||
{ 60, REAL_FFT60_CONFIG },
|
||
{ 60, REAL_IFFT60_CONFIG },
|
||
{ 64, REAL_FFT64_CONFIG },
|
||
{ 64, REAL_IFFT64_CONFIG },
|
||
{ 80, REAL_FFT80_CONFIG },
|
||
{ 80, REAL_IFFT80_CONFIG },
|
||
{ 120, REAL_FFT120_CONFIG },
|
||
{ 120, REAL_IFFT120_CONFIG },
|
||
{ 160, REAL_FFT160_CONFIG },
|
||
{ 160, REAL_IFFT160_CONFIG },
|
||
{ 240, REAL_FFT240_CONFIG },
|
||
{ 240, REAL_IFFT240_CONFIG },
|
||
{ 320, REAL_FFT320_CONFIG },
|
||
{ 320, REAL_IFFT320_CONFIG },
|
||
{ 480, REAL_FFT480_CONFIG },
|
||
{ 480, REAL_IFFT480_CONFIG },
|
||
{ 960, REAL_FFT960_CONFIG },
|
||
{ 960, REAL_IFFT960_CONFIG },
|
||
};
|
||
|
||
|
||
#ifdef KISS_FFT
|
||
|
||
//是否使用软硬混合fft
|
||
#define SOFT_FFT_ENABLE
|
||
|
||
typedef struct kiss_config {
|
||
kiss_fft_cfg forward;
|
||
kiss_fft_cfg backward;
|
||
int N;
|
||
float *fft_in;
|
||
float *fft_out;
|
||
} kiss_config_t;
|
||
|
||
static kiss_config_t *kiss_512;
|
||
static kiss_config_t *kiss_1024;
|
||
|
||
|
||
static u8 spin_is_lock()
|
||
{
|
||
return fft_lock.rwlock;
|
||
}
|
||
|
||
//input: only real
|
||
//output: interleave real and image, size is (N/2+1)*2
|
||
__attribute__((always_inline))
|
||
void kiss_cfg_fft(void *table, int *in, int *out)
|
||
{
|
||
kiss_config_t *t = (kiss_config_t *)table;
|
||
|
||
float scale = 1;// / t->N;
|
||
|
||
for (int i = 0; i < t->N; i++) {
|
||
t->fft_in[i * 2] = in[i] * scale;
|
||
t->fft_in[i * 2 + 1] = 0;
|
||
}
|
||
|
||
kiss_fft(t->forward, t->fft_in, t->fft_out);
|
||
|
||
for (int i = 0; i < t->N + 2; i++) {
|
||
out[i] = t->fft_out[i];
|
||
}
|
||
}
|
||
|
||
//output: only real
|
||
//input: interleave real and image, size is (N/2+1)*2
|
||
__attribute__((always_inline))
|
||
void kiss_cfg_ifft(void *table, int *in, int *out)
|
||
{
|
||
kiss_config_t *t = (kiss_config_t *)table;
|
||
|
||
float scale;
|
||
int i;
|
||
scale = 1.0f / t->N;
|
||
|
||
for (int i = 0; i < t->N / 2 + 1; i++) {
|
||
t->fft_in[i * 2] = in[i * 2];
|
||
t->fft_in[i * 2 + 1] = in[i * 2 + 1];
|
||
}
|
||
for (int i = t->N / 2 + 1; i < t->N; i++) {
|
||
t->fft_in[i * 2] = t->fft_in[(t->N - i) * 2];
|
||
t->fft_in[i * 2 + 1] = -t->fft_in[(t->N - i) * 2 + 1];
|
||
}
|
||
|
||
kiss_fft(t->backward, t->fft_in, t->fft_out);
|
||
|
||
for (int i = 0; i < t->N; i++) {
|
||
out[i] = t->fft_out[i * 2];
|
||
}
|
||
|
||
for (i = 0; i < t->N; i++) {
|
||
out[i] *= scale;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
void kiss_config_uninit()
|
||
{
|
||
if (kiss_512->fft_in) {
|
||
free(kiss_512->fft_in);
|
||
kiss_512->fft_in = NULL;
|
||
}
|
||
if (kiss_512->fft_out) {
|
||
free(kiss_512->fft_out);
|
||
kiss_512->fft_out = NULL;
|
||
}
|
||
kiss_fft_free(kiss_512->forward);
|
||
kiss_fft_free(kiss_512->backward);
|
||
free(kiss_512);
|
||
|
||
if (kiss_1024->fft_in) {
|
||
free(kiss_1024->fft_in);
|
||
kiss_1024->fft_in = NULL;
|
||
}
|
||
if (kiss_1024->fft_out) {
|
||
free(kiss_1024->fft_out);
|
||
kiss_1024->fft_out = NULL;
|
||
}
|
||
kiss_fft_free(kiss_1024->forward);
|
||
kiss_fft_free(kiss_1024->backward);
|
||
free(kiss_1024);
|
||
}
|
||
|
||
void kiss_config_init()
|
||
{
|
||
kiss_512 = (kiss_config_t *)calloc(1, sizeof(kiss_config_t));
|
||
if (!kiss_512) {
|
||
printf("%s, kiss_512 malloc fail\n\r", __func__);
|
||
return;
|
||
}
|
||
kiss_1024 = (kiss_config_t *)calloc(1, sizeof(kiss_config_t));
|
||
if (!kiss_1024) {
|
||
printf("%s, kiss_1024 malloc fail\n\r", __func__);
|
||
return;
|
||
}
|
||
|
||
kiss_512->N = 512;
|
||
kiss_512->forward = kiss_fft_alloc(kiss_512->N, 0, NULL, NULL);
|
||
kiss_512->backward = kiss_fft_alloc(kiss_512->N, 1, NULL, NULL);
|
||
|
||
kiss_512->fft_in = (float *)calloc(1, sizeof(float) * kiss_512->N * 2);
|
||
if (!kiss_512->fft_in) {
|
||
printf("%s, kiss_512 fft_in malloc fail\n\r", __func__);
|
||
return;
|
||
}
|
||
kiss_512->fft_out = (float *)calloc(1, sizeof(float) * kiss_512->N * 2);
|
||
if (!kiss_512->fft_out) {
|
||
printf("%s, kiss_512 fft_out malloc fail\n\r", __func__);
|
||
return;
|
||
}
|
||
|
||
kiss_1024->N = 1024;
|
||
kiss_1024->forward = kiss_fft_alloc(kiss_1024->N, 0, NULL, NULL);
|
||
kiss_1024->backward = kiss_fft_alloc(kiss_1024->N, 1, NULL, NULL);
|
||
|
||
kiss_1024->fft_in = (float *)calloc(1, sizeof(float) * kiss_1024->N * 2);
|
||
if (!kiss_1024->fft_in) {
|
||
printf("%s, kiss_1024 fft_in malloc fail\n\r", __func__);
|
||
return;
|
||
}
|
||
kiss_1024->fft_out = (float *)calloc(1, sizeof(float) * kiss_1024->N * 2);
|
||
if (!kiss_1024->fft_out) {
|
||
printf("%s, kiss_1024 fft_out malloc fail\n\r", __func__);
|
||
return;
|
||
}
|
||
|
||
}
|
||
|
||
late_initcall(kiss_config_init);
|
||
|
||
#endif
|
||
|
||
|
||
__attribute__((always_inline))
|
||
static int vc_hw_fft(int *coef_in, int blockbit, int *coef_out, int real, int same)
|
||
{
|
||
//init pi32v2 fft hardware
|
||
int blocklen = 1 << blockbit;
|
||
JL_FFT->CON = 0;
|
||
|
||
#ifdef CONFIG_CPU_WL82
|
||
int i;
|
||
|
||
if (real) {
|
||
for (i = 0; i < ARRAY_SIZE(real_tab); i += 2) {
|
||
if (blocklen == real_tab[i].block) {
|
||
fft_config.fft0_con = real_tab[i].config | (same << 0);
|
||
break;
|
||
}
|
||
}
|
||
if (i >= ARRAY_SIZE(real_tab)) {
|
||
return -1;
|
||
}
|
||
} else {
|
||
for (i = 0; i < ARRAY_SIZE(complex_tab); i += 2) {
|
||
if (blocklen == complex_tab[i].block) {
|
||
fft_config.fft0_con = complex_tab[i].config | (same << 0);
|
||
break;
|
||
}
|
||
}
|
||
if (i >= ARRAY_SIZE(complex_tab)) {
|
||
return -1;
|
||
}
|
||
}
|
||
#else
|
||
fft_config.fft0_con = (blocklen << 16) | ((blockbit - 1 - real) << 8) | ((blockbit - real - 2) << 4) | (0 << 2) | (real << 1) | (same << 0);
|
||
#endif
|
||
fft_config.fft0_iadr = (unsigned int)coef_in;
|
||
fft_config.fft0_oadr = (unsigned int)coef_out;
|
||
|
||
JL_FFT->CADR = (unsigned int)&fft_config;
|
||
JL_FFT->CON = (1 << 8) | (0 << 6) | (FFT_ISR_IE << 2) | (0 << 1) | (1 << 0);
|
||
while ((JL_FFT->CON & (1 << 7)) == 0);
|
||
JL_FFT->CON |= (1 << 6);
|
||
return 0;
|
||
}
|
||
|
||
__attribute__((always_inline))
|
||
static int vc_hw_ifft(int *coef_in, int blockbit, int *coef_out, int real, int same)
|
||
{
|
||
//init pi32v2 fft hardware
|
||
int blocklen = 1 << blockbit;
|
||
JL_FFT->CON = 0;
|
||
|
||
#ifdef CONFIG_CPU_WL82
|
||
int i;
|
||
|
||
if (real) {
|
||
for (i = 0; i < ARRAY_SIZE(real_tab); i += 2) {
|
||
if (blocklen == real_tab[i + 1].block) {
|
||
fft_config.fft0_con = real_tab[i + 1].config | (same << 0);
|
||
break;
|
||
}
|
||
}
|
||
if (i >= ARRAY_SIZE(real_tab)) {
|
||
return -1;
|
||
}
|
||
} else {
|
||
for (i = 0; i < ARRAY_SIZE(complex_tab); i += 2) {
|
||
if (blocklen == complex_tab[i + 1].block) {
|
||
fft_config.fft0_con = complex_tab[i + 1].config | (same << 0);
|
||
break;
|
||
}
|
||
}
|
||
if (i >= ARRAY_SIZE(complex_tab)) {
|
||
return -1;
|
||
}
|
||
}
|
||
#else
|
||
fft_config.fft0_con = (blocklen << 16) | ((blockbit - 1 - real) << 8) | ((3 - real) << 4) | (1 << 2) | (real << 1) | (same << 0);
|
||
#endif
|
||
fft_config.fft0_iadr = (unsigned int)coef_in;
|
||
fft_config.fft0_oadr = (unsigned int)coef_out;
|
||
|
||
JL_FFT->CADR = (unsigned int)&fft_config;
|
||
JL_FFT->CON = (1 << 8) | (0 << 6) | (FFT_ISR_IE << 2) | (0 << 1) | (1 << 0);
|
||
while ((JL_FFT->CON & (1 << 7)) == 0);
|
||
JL_FFT->CON |= (1 << 6);
|
||
return 0;
|
||
}
|
||
|
||
/* SEC_USED(.fft_text) */
|
||
__attribute__((always_inline))
|
||
void jl_fft_1024(short *in, int *out)
|
||
{
|
||
spin_lock(&fft_lock);
|
||
for (int i = 0; i < 1024; i++) {
|
||
datain[i] = in[i];
|
||
}
|
||
vc_hw_fft(datain, 10, dataout, 1, datain == dataout ? 1 : 0);
|
||
memcpy(out, dataout, sizeof(int) * 1026);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
|
||
/* SEC_USED(.fft_text) */
|
||
__attribute__((always_inline))
|
||
void jl_fft_1024_ex(int *in, int *out)
|
||
{
|
||
#ifdef SOFT_FFT_ENABLE
|
||
if (spin_is_lock()) {
|
||
kiss_cfg_fft(kiss_1024, in, out);
|
||
} else
|
||
#endif
|
||
{
|
||
spin_lock(&fft_lock);
|
||
memcpy(datain, in, sizeof(int) * 1024);
|
||
vc_hw_fft(datain, 10, dataout, 1, datain == dataout ? 1 : 0);
|
||
memcpy(out, dataout, sizeof(int) * 1026);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
}
|
||
|
||
/* SEC_USED(.fft_text) */
|
||
__attribute__((always_inline))
|
||
void jl_fft_512(int *in, int *out)
|
||
{
|
||
#ifdef SOFT_FFT_ENABLE
|
||
if (spin_is_lock()) {
|
||
kiss_cfg_fft(kiss_512, in, out);
|
||
} else
|
||
#endif
|
||
{
|
||
spin_lock(&fft_lock);
|
||
memcpy(datain, in, sizeof(int) * 512);
|
||
vc_hw_fft(datain, 9, dataout, 1, datain == dataout ? 1 : 0);
|
||
memcpy(out, dataout, sizeof(int) * 514);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
}
|
||
|
||
/* SEC_USED(.fft_text) */
|
||
__attribute__((always_inline))
|
||
int jl_ifft_1024(int *in, short *out)
|
||
{
|
||
int i;
|
||
int tData_tmp = 0, tData_max = 0, shift = 0;
|
||
spin_lock(&fft_lock);
|
||
memcpy(dataout, in, sizeof(int) * 1026);
|
||
vc_hw_ifft(dataout, 10, datain, 1, dataout == datain ? 1 : 0);
|
||
for (i = 0; i < 1024; i++) {
|
||
tData_tmp = datain[i] > 0 ? datain[i] : (-datain[i]);
|
||
|
||
if (tData_max < tData_tmp) {
|
||
tData_max = tData_tmp;
|
||
}
|
||
}
|
||
while (tData_max > 32767) {
|
||
tData_max >>= 1;
|
||
shift += 1;
|
||
}
|
||
for (i = 0; i < 1024; i += 4) {
|
||
out[i] = PSHR(datain[i], shift);
|
||
out[i + 1] = PSHR(datain[i + 1], shift);
|
||
out[i + 2] = PSHR(datain[i + 2], shift);
|
||
out[i + 3] = PSHR(datain[i + 3], shift);
|
||
}
|
||
spin_unlock(&fft_lock);
|
||
return shift;
|
||
}
|
||
|
||
/* SEC_USED(.fft_text) */
|
||
__attribute__((always_inline))
|
||
void jl_ifft_1024_ex(int *in, int *out)
|
||
{
|
||
#ifdef SOFT_FFT_ENABLE
|
||
if (spin_is_lock()) {
|
||
kiss_cfg_ifft(kiss_1024, in, out);
|
||
} else
|
||
#endif
|
||
{
|
||
spin_lock(&fft_lock);
|
||
memcpy(dataout, in, sizeof(int) * 1026);
|
||
vc_hw_ifft(dataout, 10, datain, 1, dataout == datain ? 1 : 0);
|
||
memcpy(out, datain, sizeof(int) * 1024);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
}
|
||
|
||
/* SEC_USED(.fft_text) */
|
||
__attribute__((always_inline))
|
||
void jl_ifft_512(int *in, int *out)
|
||
{
|
||
#ifdef SOFT_FFT_ENABLE
|
||
if (spin_is_lock()) {
|
||
kiss_cfg_ifft(kiss_512, in, out);
|
||
} else
|
||
#endif
|
||
{
|
||
spin_lock(&fft_lock);
|
||
memcpy(datain, in, sizeof(int) * 514);
|
||
vc_hw_ifft(datain, 9, dataout, 1, dataout == datain ? 1 : 0);
|
||
memcpy(out, dataout, sizeof(int) * 512);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
}
|
||
|
||
__attribute__((always_inline))
|
||
static u32 find_pow(u32 value)
|
||
{
|
||
u32 i = 0;
|
||
|
||
while (value) {
|
||
value >>= 1;
|
||
if (++i > 11) {
|
||
ASSERT(NULL, "pow <= 10");
|
||
}
|
||
}
|
||
|
||
return i - 1;
|
||
}
|
||
|
||
__attribute__((always_inline))
|
||
void jl_fft_N(int *in, int *out, int fft_N)
|
||
{
|
||
spin_lock(&fft_lock);
|
||
memcpy(datain, in, sizeof(int) * fft_N);
|
||
vc_hw_fft(datain, find_pow(fft_N), dataout, 1, dataout == datain ? 1 : 0);
|
||
memcpy(out, dataout, sizeof(int) * (fft_N + 2));
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
|
||
__attribute__((always_inline))
|
||
void jl_ifft_N(int *in, int *out, int fft_N)
|
||
{
|
||
spin_lock(&fft_lock);
|
||
memcpy(dataout, in, sizeof(int) * (fft_N + 2));
|
||
vc_hw_ifft(dataout, find_pow(fft_N), datain, 1, dataout == datain ? 1 : 0);
|
||
memcpy(out, datain, sizeof(int) * fft_N);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
|
||
__attribute__((always_inline))
|
||
void jl_complex_fft_n(int *in, int *out, int bits)
|
||
{
|
||
int len = 1 << bits;
|
||
spin_lock(&fft_lock);
|
||
memcpy(datain, in, sizeof(int) * len);
|
||
vc_hw_fft(datain, bits - 1, dataout, 0, datain == dataout ? 1 : 0);
|
||
memcpy(out, dataout, sizeof(int) * len);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
|
||
__attribute__((always_inline))
|
||
void jl_complex_ifft_n(int *in, int *out, int bits)
|
||
{
|
||
int len = 1 << bits;
|
||
spin_lock(&fft_lock);
|
||
memcpy(datain, in, sizeof(int) * len);
|
||
vc_hw_ifft(datain, bits - 1, dataout, 0, datain == dataout ? 1 : 0);
|
||
memcpy(out, dataout, sizeof(int) * len);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
|
||
void hw_fft_run(int cfg, const int *coef_in, int *coef_out)
|
||
{
|
||
int len;
|
||
int *in = datain, *out = dataout;
|
||
|
||
if (!coef_in || !coef_out) {
|
||
return;
|
||
}
|
||
|
||
if (datain == dataout) {
|
||
cfg |= BIT(0);
|
||
} else {
|
||
cfg &= ~BIT(0);
|
||
}
|
||
|
||
if (cfg & BIT(1)) {
|
||
len = (cfg & 0xFFF0000) >> 16;
|
||
if (cfg & BIT(2)) {
|
||
len += 2;
|
||
in = dataout;
|
||
out = datain;
|
||
}
|
||
} else {
|
||
len = (cfg & 0xFFF0000) >> (16 - 1);
|
||
}
|
||
|
||
spin_lock(&fft_lock);
|
||
memcpy(in, coef_in, sizeof(int) * len);
|
||
|
||
JL_FFT->CON = 0;
|
||
fft_config.fft0_con = cfg;
|
||
fft_config.fft0_iadr = (unsigned int)in;
|
||
fft_config.fft0_oadr = (unsigned int)out;
|
||
JL_FFT->CADR = (unsigned int)&fft_config;
|
||
JL_FFT->CON = (1 << 8) | (0 << 6) | (FFT_ISR_IE << 2) | (0 << 1) | (1 << 0);
|
||
while ((JL_FFT->CON & (1 << 7)) == 0);
|
||
JL_FFT->CON |= (1 << 6);
|
||
|
||
if (cfg & BIT(1)) {
|
||
if (cfg & BIT(2)) {
|
||
len -= 2;
|
||
} else {
|
||
len += 2;
|
||
}
|
||
}
|
||
|
||
memcpy(coef_out, out, sizeof(int) * len);
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
|
||
void hw_fft_wrap(fft_config_struct *ctx)
|
||
{
|
||
hw_fft_run(ctx->fft0_con, (const int *)ctx->fft0_iadr, (int *)ctx->fft0_oadr);
|
||
}
|
||
|
||
#if defined CONFIG_NEW_M4A_DEC_ENABLE
|
||
int hw_fft_core(int cfg, const int *coef_in, int *coef_out)
|
||
{
|
||
hw_fft_run(cfg, coef_in, coef_out);
|
||
}
|
||
#endif
|
||
|
||
unsigned int Get_FFT_Base(void)
|
||
{
|
||
return JL_FFT_BASE;
|
||
}
|
||
|
||
__attribute__((always_inline)) inline
|
||
void fast_i2f(const int *in, float *out, int N, float scale)
|
||
{
|
||
int tmp32_1;
|
||
asm volatile(
|
||
" 1: \n\t"
|
||
" rep %1 { \n\t"
|
||
" %0 = [%2++=4] \n\t"
|
||
" %0 = itof(%0) \n\t"
|
||
" %0 = %0 * %4 (f) \n\t"
|
||
" [%3++=4] = %0 \n\t"
|
||
" } \n\t"
|
||
" if(%1>0) goto 1b \n\t"
|
||
: "=&r"(tmp32_1),
|
||
"=&r"(N),
|
||
"=&r"(in),
|
||
"=&r"(out),
|
||
"=&r"(scale)
|
||
: "0"(tmp32_1),
|
||
"1"(N),
|
||
"2"(in),
|
||
"3"(out),
|
||
"4"(scale)
|
||
:);
|
||
}
|
||
|
||
__attribute__((always_inline)) inline
|
||
void fast_f2i(const float *in, int *out, int N, float scale)
|
||
{
|
||
int tmp32_1;
|
||
asm volatile(
|
||
" 1: \n\t"
|
||
" rep %1 { \n\t"
|
||
" %0 = [%2++=4] \n\t"
|
||
" %0 = %0 * %4 (f) \n\t"
|
||
" %0 = ftoi(%0)(even) \n\t"
|
||
" [%3++=4] = %0 \n\t"
|
||
" } \n\t"
|
||
" if(%1>0) goto 1b \n\t"
|
||
: "=&r"(tmp32_1),
|
||
"=&r"(N),
|
||
"=&r"(in),
|
||
"=&r"(out),
|
||
"=&r"(scale)
|
||
: "0"(tmp32_1),
|
||
"1"(N),
|
||
"2"(in),
|
||
"3"(out),
|
||
"4"(scale)
|
||
:);
|
||
}
|
||
|
||
//hwfft_ctx_t结构体和FFT输入输出的数据地址一定要放在内部ram
|
||
|
||
__attribute__((always_inline)) inline
|
||
void hwfft_exec_batch(hwfft_ctx_t *ctx, int nbatch)
|
||
{
|
||
spin_lock(&fft_lock);
|
||
JL_FFT->CADR = (unsigned long)(ctx);
|
||
//CLR //FFT //ie //en
|
||
JL_FFT->CON = (nbatch << 8) | (1 << 6) | (0 << 3) | (FFT_ISR_IE << 2) | (1 << 0);
|
||
while ((JL_FFT->CON & (1 << 7)) == 0);
|
||
JL_FFT->CON |= (1 << 6);
|
||
spin_unlock(&fft_lock);
|
||
};
|
||
|
||
__attribute__((always_inline)) inline
|
||
void hwfft_exec_once(hwfft_ctx_t *ctx)
|
||
{
|
||
spin_lock(&fft_lock);
|
||
JL_FFT->CADR = (unsigned long)(ctx);
|
||
//CLR //FFT //ie //en
|
||
JL_FFT->CON = (1 << 8) | (1 << 6) | (0 << 3) | (FFT_ISR_IE << 2) | (1 << 0);
|
||
while ((JL_FFT->CON & (1 << 7)) == 0);
|
||
JL_FFT->CON |= (1 << 6);
|
||
spin_unlock(&fft_lock);
|
||
};
|
||
|
||
__attribute__((always_inline)) inline
|
||
int hwfft_get_nfft(unsigned long fft_config)
|
||
{
|
||
int nfft = (fft_config >> 16) & 0xfff;
|
||
return nfft;
|
||
};
|
||
|
||
//0---forward 1---backward
|
||
__attribute__((always_inline)) inline
|
||
int hwfft_get_backward(unsigned long fft_config)
|
||
{
|
||
return ((fft_config & (1 << 2)) != 0);
|
||
};
|
||
|
||
//0---complex 1---real
|
||
__attribute__((always_inline)) inline
|
||
int hwfft_get_real(unsigned long fft_config)
|
||
{
|
||
return ((fft_config & (1 << 1)) != 0);
|
||
};
|
||
|
||
__attribute__((always_inline)) inline
|
||
int hwfft_check_fft_config(unsigned long fft_config, int nfft, int backward, int real)
|
||
{
|
||
if (hwfft_get_nfft(fft_config) != nfft) {
|
||
printf("fft nfft mismatch!\n");
|
||
return -1;
|
||
}
|
||
|
||
if (hwfft_get_backward(fft_config) != backward) {
|
||
printf("fft backward direction mismatch!\n");
|
||
return -1;
|
||
}
|
||
|
||
if (hwfft_get_real(fft_config) != real) {
|
||
printf("fft real mode mismatch!\n");
|
||
return -1;
|
||
}
|
||
return 0;
|
||
};
|
||
|
||
__attribute__((always_inline)) inline
|
||
void hwfft_fill_fft_ctx(hwfft_ctx_t *ctx, unsigned long fft_config, long *iadr, long *oadr)
|
||
{
|
||
unsigned long config;
|
||
|
||
if (iadr == oadr) {
|
||
config = fft_config | FFT_SAME_ADR;
|
||
} else {
|
||
config = fft_config & (~FFT_SAME_ADR);
|
||
}
|
||
ctx->fft_con = config;
|
||
ctx->fft_iadr = (unsigned long)iadr;
|
||
ctx->fft_oadr = (unsigned long)oadr;
|
||
ctx->fft_null = 0;
|
||
// printf("config1:%d %x\n",config,ctx->fft_iadr);
|
||
};
|
||
|
||
__attribute__((always_inline)) inline
|
||
void hwfft_ifft_scale(long *iadr, int nfft)
|
||
{
|
||
int scale;
|
||
int q;
|
||
long config = VECX_S32 | VECY_S32 | VECZ_S32;
|
||
// printf("nfft:%d\n",nfft);
|
||
|
||
if (nfft % 15 == 0) {
|
||
scale = 1118481;
|
||
q = 21;
|
||
vector_real_mul_const(iadr, iadr, nfft, q, scale, config);
|
||
} else if (nfft % 10 == 0) {
|
||
scale = 1677722;//1864135;
|
||
q = 21;
|
||
vector_real_mul_const(iadr, iadr, nfft, q, scale, config);
|
||
}
|
||
}
|
||
|
||
__attribute__((always_inline)) inline
|
||
void hwfft_fft_i32(hwfft_ctx_t *ctx)
|
||
{
|
||
hwfft_exec_once(ctx);
|
||
};
|
||
|
||
__attribute__((always_inline)) inline
|
||
void hwfft_ifft_i32(hwfft_ctx_t *ctx)
|
||
{
|
||
int real = hwfft_get_real(ctx->fft_con);
|
||
int nfft = hwfft_get_nfft(ctx->fft_con);
|
||
hwfft_exec_once(ctx);
|
||
|
||
hwfft_ifft_scale((long *)ctx->fft_oadr, nfft * (2 - real));
|
||
};
|
||
|
||
__attribute__((always_inline)) inline
|
||
void hwfft_fft_f32(hwfft_ctx_t *ctx, float scale)
|
||
{
|
||
int nfft = hwfft_get_nfft(ctx->fft_con);
|
||
int real = hwfft_get_real(ctx->fft_con);
|
||
fast_f2i((float *)ctx->fft_iadr, (int *)ctx->fft_iadr, nfft * (2 - real), scale);
|
||
hwfft_fft_i32(ctx);
|
||
fast_i2f((int *)ctx->fft_oadr, (float *)ctx->fft_oadr, nfft * (2 - real) + 2 * real, 1.0f / scale); // com 0 real 1
|
||
};
|
||
|
||
__attribute__((always_inline)) inline
|
||
void hwfft_ifft_f32(hwfft_ctx_t *ctx, float scale)
|
||
{
|
||
int nfft = hwfft_get_nfft(ctx->fft_con);
|
||
int real = hwfft_get_real(ctx->fft_con);
|
||
|
||
fast_f2i((float *)ctx->fft_iadr, (int *)ctx->fft_iadr, nfft * (2 - real) + 2 * real, scale);
|
||
|
||
hwfft_ifft_i32(ctx);
|
||
|
||
fast_i2f((int *)ctx->fft_oadr, (float *)ctx->fft_oadr, nfft * (2 - real), 1.0f / scale);
|
||
};
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
//VECTOR
|
||
__attribute__((always_inline)) inline
|
||
void hwvec_exec(
|
||
void *xptr,
|
||
void *yptr,
|
||
void *zptr,
|
||
short x_inc,
|
||
short y_inc,
|
||
short z_inc,
|
||
short nlen,
|
||
short nloop,
|
||
char q,
|
||
long config,
|
||
long const_dat
|
||
)
|
||
{
|
||
//硬件锁上锁
|
||
spin_lock(&fft_lock);
|
||
|
||
char vec_cpy_real = 0;
|
||
char vec_zptr_cpy_dot = 0;
|
||
|
||
//获取段内数组的地址, 硬件运算数据都需在段内进行
|
||
void *_xptr = &datain[0];
|
||
void *_yptr = &datain_y[0];
|
||
void *_zptr = &dataout[0];
|
||
|
||
//区分复制长度(nlen为数据个数)是实数还是复数, 复数需乘2
|
||
if (config & VEC_CPY_REAL_OR_VEC) {
|
||
vec_cpy_real = 1;
|
||
config &= ~VEC_CPY_REAL_OR_VEC;
|
||
#ifdef CONFIG_CPU_WL82
|
||
if (xptr < (void *)__NONCPU_ADDR__) {
|
||
_xptr = xptr;
|
||
} else
|
||
#endif
|
||
{
|
||
memcpy(_xptr, xptr, nlen * 4);
|
||
}
|
||
//是否需要复制输入YPTR
|
||
if (config & VEC_YPTR_NOCPY) {
|
||
config &= ~VEC_YPTR_NOCPY;
|
||
} else {
|
||
#ifdef CONFIG_CPU_WL82
|
||
if (yptr < (void *)__NONCPU_ADDR__) {
|
||
_yptr = yptr;
|
||
} else
|
||
#endif
|
||
{
|
||
memcpy(_yptr, yptr, nlen * 4);
|
||
}
|
||
}
|
||
} else {
|
||
#ifdef CONFIG_CPU_WL82
|
||
if (xptr < (void *)__NONCPU_ADDR__) {
|
||
_xptr = xptr;
|
||
} else
|
||
#endif
|
||
{
|
||
memcpy(_xptr, xptr, nlen * 4 * 2);
|
||
}
|
||
//是否需要复制输入YPTR
|
||
if (config & VEC_YPTR_NOCPY) {
|
||
config &= ~VEC_YPTR_NOCPY;
|
||
} else {
|
||
#ifdef CONFIG_CPU_WL82
|
||
if (yptr < (void *)__NONCPU_ADDR__) {
|
||
_yptr = yptr;
|
||
} else
|
||
#endif
|
||
{
|
||
memcpy(_yptr, yptr, nlen * 4 * 2);
|
||
}
|
||
}
|
||
}
|
||
|
||
//是否需要输入zptr数据
|
||
if (config & VEC_ZPTR_CPY) {
|
||
config &= ~VEC_ZPTR_CPY;
|
||
if (vec_cpy_real) {
|
||
#ifdef CONFIG_CPU_WL82
|
||
if (zptr < (void *)__NONCPU_ADDR__) {
|
||
_zptr = zptr;
|
||
} else
|
||
#endif
|
||
{
|
||
memcpy(_zptr, zptr, nlen * 4);
|
||
}
|
||
} else {
|
||
#ifdef CONFIG_CPU_WL82
|
||
if (zptr < (void *)__NONCPU_ADDR__) {
|
||
_zptr = zptr;
|
||
} else
|
||
#endif
|
||
{
|
||
memcpy(_zptr, zptr, nlen * 4 * 2);
|
||
}
|
||
}
|
||
} else if (zptr == xptr) {
|
||
_zptr = _xptr;
|
||
} else if (zptr == yptr) {
|
||
_zptr = _yptr;
|
||
}
|
||
|
||
//区分ZPTR输出结果复制长度是一个点还是向量
|
||
if (config & VEC_ZPTR_CPY_DOT) {
|
||
vec_zptr_cpy_dot = 1;
|
||
config &= ~VEC_ZPTR_CPY_DOT;
|
||
}
|
||
|
||
//VECTOR寄存器的配置
|
||
g_vector_core_set.vector_con = config;
|
||
g_vector_core_set.vector_config0 = (q << 24) | (nloop << 12) | (nlen);
|
||
g_vector_core_set.vector_config1 = (z_inc << 20) | (y_inc << 10) | x_inc;
|
||
//printf("nlen0:%d,nloop:%d,q:%d,config:%d,%d\n",nlen,nloop,q,config,const_dat);
|
||
|
||
g_vector_core_set.vector_xadr = (unsigned long)_xptr;
|
||
g_vector_core_set.vector_yadr = (unsigned long)_yptr;
|
||
g_vector_core_set.vector_zadr = (unsigned long)_zptr;
|
||
|
||
JL_FFT->CONST = const_dat;
|
||
|
||
JL_FFT->CADR = (unsigned long)(&g_vector_core_set);
|
||
/*printf("JL_FFT->CONST:%x\n",&g_vector_core_set);
|
||
printf("JL_FFT->vector_xadr:%x\n",g_vector_core_set.vector_xadr);
|
||
printf("JL_FFT->vector_yadr:%x\n",g_vector_core_set.vector_yadr);
|
||
printf("JL_FFT->vector_zadr:%x\n",g_vector_core_set.vector_zadr);
|
||
printf("JL_FFT->vector_config0:%x\n",g_vector_core_set.vector_config0);
|
||
printf("JL_FFT->vector_config1:%x\n",g_vector_core_set.vector_config1);*/
|
||
|
||
//开始运算
|
||
//nu | clr | vector | ie | en
|
||
JL_FFT->CON = (1 << 8) | (1 << 6) | (1 << 3) | (FFT_ISR_IE << 2) | (1 << 0);
|
||
|
||
//等待运算完成中断并清中断
|
||
while ((JL_FFT->CON & (1 << 7)) == 0);
|
||
JL_FFT->CON |= (1 << 6);
|
||
|
||
//获取输出数据
|
||
if (vec_zptr_cpy_dot) {
|
||
*(int *)zptr = *(int *)_zptr;
|
||
} else {
|
||
memcpy(zptr, _zptr, vec_cpy_real ? nlen * 4 : nlen * 4 * 2);
|
||
}
|
||
|
||
//硬件锁解锁
|
||
spin_unlock(&fft_lock);
|
||
}
|
||
|
||
|
||
|
||
//=========================================================================
|
||
// vector_complex_add
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
//
|
||
// x.real[0] = x[0], x.imge[0] = x[1]
|
||
// y.real[0] = y[0], y.imge[0] = y[1]
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = saturated( y[n] + x[n] ) // 0 <= n < len*2
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_complex_add(void *zptr, void *yptr, void *xptr, short len, long config)
|
||
{
|
||
config = config;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, (len << 1), 1, 0, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_complex_sub
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
//
|
||
// x.real[0] = x[0], x.imge[0] = x[1]
|
||
// y.real[0] = y[0], y.imge[0] = y[1]
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = saturated( y[n] - x[n] ) // 0 <= n < len*2
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_complex_sub(void *zptr, void *yptr, void *xptr, short len, long config)
|
||
{
|
||
config = config | VEC_SUB;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, (len << 1), 1, 0, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_complex_mul
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
// -32 < Q < 31
|
||
// x.real[0] = x[0], x.imge[0] = x[1]
|
||
// y.real[0] = y[0], y.imge[0] = y[1]
|
||
// z.real[0] = z[0], z.imge[0] = z[1]
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = saturated(y[n]. * x[n]. / 2^q) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_complex_mul(void *zptr, void *yptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_CPX_MUL_MODE;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, (len << 0), 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_complex_mac32
|
||
// dw bit[1:0] : x_dw 2: s32
|
||
// dw bit[3:2] : y_dw 2: s32
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// y_dw == z_dw == x_dw == 2
|
||
// -32 < Q < 31
|
||
// x.real[0] = x[0], x.imge[0] = x[1]
|
||
// y.real[0] = y[0], y.imge[0] = y[1]
|
||
// z.real[0] = z[0], z.imge[0] = z[1]
|
||
// *zptr, *yptr, *xptr: s32
|
||
// z[n] = saturated(z. + (y[n]. * x[n]. / 2^q)) // 0 <= n < len*2
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_complex_mac32(void *zptr, void *yptr, void *xptr, short len, char q, long config)
|
||
{
|
||
//config = VEC_MAC32 | VECZ_S32 | VECY_S32 | VECX_S32 | VEC_CPX_MUL_MODE;
|
||
config = config | VEC_MAC32 | VECZ_S32 | VECY_S32 | VECX_S32 | VEC_CPX_MUL_MODE | VEC_ZPTR_CPY;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, (len << 0), 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_complex_msc32
|
||
// dw bit[1:0] : x_dw 2: s32
|
||
// dw bit[3:2] : y_dw 2: s32
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// y_dw == z_dw == x_dw == 2
|
||
// -32 < Q < 31
|
||
// x.real[0] = x[0], x.imge[0] = x[1]
|
||
// y.real[0] = y[0], y.imge[0] = y[1]
|
||
// z.real[0] = z[0], z.imge[0] = z[1]
|
||
// *zptr, *yptr, *xptr: s32
|
||
// z[n] = saturated(z[n]. - (y[n]. * x[n]. / 2^q)) // 0 <= n < len*2
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_complex_msc32(void *zptr, void *yptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_MAC32 | VECZ_S32 | VECY_S32 | VECX_S32 | VEC_SUB | VEC_CPX_MUL_MODE;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, (len << 1), 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_complex_dot_product
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
// -32 < Q < 31
|
||
// x.real[0] = x[0], x.imge[0] = x[1]
|
||
// y.real[0] = y[0], y.imge[0] = y[1]
|
||
// z.real[0] = z[0], z.imge[0] = z[1]
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = saturated(sum(y[n]. * x[n]. / 2^q)) // 0 <= n < len*2
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_complex_dot_product(void *zptr, void *yptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_ACC | VEC_CPX_MUL_MODE;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, (len << 1), 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_complex_qdt
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
// -32 < Q < 31
|
||
// x.real[0] = x[0], x.imge[0] = x[1]
|
||
// z.real[0] = z[0], z.imge[0] = z[1]
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = saturated((x[n].real^2 + x[n].imag^2) / 2^q) // 0 <= n < len/2
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_complex_qdt(void *zptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_CPX_QDT | VEC_QDT | VEC_QDT_MODE | VEC_YPTR_NOCPY;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, (len << 1), 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_complex_qdtsum
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 3: s64 2: s32 1: s16 0:s8
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = (x[0].real^2 + x[0].image^2 + ... + x[n].real^2+ x[n].image^2) / 2^q) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_complex_qdtsum(void *zptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_QDT | VEC_ACC | VEC_QDT_MODE;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, (len << 1), 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_add
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
//
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = saturated( y[n] + x[n] ) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_add(void *zptr, void *yptr, void *xptr, short len, long config)
|
||
{
|
||
config = config | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, 0, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_add_dot_product
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
//
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z = sum( y[n] + x[n] ) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_add_dot_product(void *zptr, void *yptr, void *xptr, short len, long config)
|
||
{
|
||
config = config | VEC_CPY_REAL_OR_VEC | VEC_ZPTR_CPY_DOT;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, 0, config, 0);
|
||
}
|
||
//=========================================================================
|
||
// vector_real_sub
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
//
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = saturated( y[n] - x[n] ) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_sub(void *zptr, void *yptr, void *xptr, short len, long config)
|
||
{
|
||
config = config | VEC_SUB | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, 0, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_mul
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = saturated(y[n] * x[n] / 2^q) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_mul(void *zptr, void *yptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_REAL_MUL_MODE | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_mac
|
||
// dw bit[1:0] : x_dw 2: s32
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = (z + y*x / 2^q) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_mac32(void *zptr, void *yptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_MAC32 | VECZ_S32 | VECY_S32 | VECX_S32 | VEC_REAL_MUL_MODE | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_msc
|
||
// dw bit[1:0] : x_dw 2: s32
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = (z - y*x / 2^q) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_msc32(void *zptr, void *yptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_MAC32 | VECZ_S32 | VECY_S32 | VECX_S32 | VEC_SUB | VEC_REAL_MUL_MODE | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_dot_product
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[3:2] : y_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// y_dw >= z_dw > x_dw
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = sum(y[n] * x[n] / 2^q) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_dot_product(void *zptr, void *yptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_ACC | VEC_REAL_MUL_MODE | VEC_CPY_REAL_OR_VEC | VEC_ZPTR_CPY_DOT;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_sum
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// z_dw >= x_dw
|
||
// -32 < Q < 32
|
||
// *zptr, *xptr: s32/s16/s8
|
||
// z[n] = sum(x[n]) / 2^q // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_sum(void *zptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_ACC | VEC_QDT_MODE | VEC_CPY_REAL_OR_VEC | VEC_YPTR_NOCPY;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, len, 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_sum_dot_product
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// z_dw >= x_dw
|
||
// -32 < Q < 32
|
||
// *zptr, *xptr: s32/s16/s8
|
||
// z = sum(x[n]) / 2^q // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_sum_dot_product(void *zptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_ACC | VEC_QDT_MODE | VEC_CPY_REAL_OR_VEC | VEC_YPTR_NOCPY | VEC_ZPTR_CPY_DOT;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, len, 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_qdt
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16 0:s8
|
||
// z_dw >= x_dw
|
||
// -32 < Q < 32
|
||
// *zptr, *xptr: s32/s16/s8
|
||
// z[n] = x[n]^2 / 2^q // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_qdt(void *zptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_QDT | VEC_QDT_MODE | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, len, 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_qdtsum
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32 1: s16
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = sum(x[n]^2) / 2^q // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_qdtsum(void *zptr, void *xptr, short len, char q, long config)
|
||
{
|
||
config = config | VEC_QDT | VEC_ACC | VEC_QDT_MODE | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, len, 1, q, config, 0);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_mac_const
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = x[n] + y[n] * const_dat / 2^q // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_mac_const(void *zptr, void *yptr, void *xptr, short len, char q, long const_dat, long config)
|
||
{
|
||
config = config | VEC_CONST_MUL | VEC_REAL_MUL_MODE | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, q, config, const_dat);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_msc_const
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = x[n] - y[n] * const_dat / 2^q // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_msc_const(void *zptr, void *yptr, void *xptr, short len, char q, long const_dat, long config)
|
||
{
|
||
config = config | VEC_CONST_MUL | VEC_SUB | VEC_REAL_MUL_MODE | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, yptr, zptr, 0, 0, 0, len, 1, q, config, const_dat);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_mul_const
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// -32 < Q < 32
|
||
// *zptr, *yptr, *xptr: s32/s16/s8
|
||
// z[n] = (x[n] * const_dat/ 2^q) // 0 <= n < len
|
||
// z, y, x buf size must be(32bit x n), z_buf can be y_buf or x_buf
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_mul_const(void *zptr, void *xptr, short len, char q, long const_dat, long config)
|
||
{
|
||
config = config | VEC_CONST_MUL | VEC_QDT | VEC_QDT_MODE | VEC_YPTR_NOCPY | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, len, 1, q, config, const_dat);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_max
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// -32 < Q < 32
|
||
// z = x*cosnt /2^q
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_max(void *zptr, void *xptr, short len, char q, long config, long const_dat)
|
||
{
|
||
config = config | VEC_MAX | VEC_CONST_MUL | VEC_QDT | VEC_QDT_MODE | VEC_YPTR_NOCPY | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, len, 1, q, config, const_dat);
|
||
}
|
||
|
||
//=========================================================================
|
||
// vector_real_min
|
||
// dw bit[1:0] : x_dw 2: s32 1: s16 0:s8
|
||
// dw bit[5:6] : z_dw 2: s32
|
||
// -32 < Q < 32
|
||
// z = x*cosnt /2^q
|
||
//=========================================================================
|
||
__attribute__((always_inline)) inline
|
||
void vector_real_min(void *zptr, void *xptr, short len, char q, long config, long const_dat)
|
||
{
|
||
config = config | VEC_MIN | VEC_CONST_MUL | VEC_QDT | VEC_QDT_MODE | VEC_YPTR_NOCPY | VEC_CPY_REAL_OR_VEC;
|
||
hwvec_exec(xptr, 0, zptr, 0, 0, 0, len, 1, q, config, const_dat);
|
||
}
|
||
|
||
#endif
|
||
|
||
#if defined CONFIG_FPGA_TEST_ENABLE && !defined CONFIG_VIDEO_ENABLE
|
||
|
||
#include "os/os_api.h"
|
||
#include "init.h"
|
||
|
||
void REAL_FFT_FUN(int *data, int blockbit, int *oudata)
|
||
{
|
||
vc_hw_fft(data, blockbit, oudata, 1, data == oudata ? 1 : 0);
|
||
}
|
||
|
||
void REAL_IFFT_FUN(int *data, int blockbit, int *oudata)
|
||
{
|
||
vc_hw_ifft(data, blockbit, oudata, 1, data == oudata ? 1 : 0);
|
||
}
|
||
|
||
void COMPLEX_FFT_FUN(int *data, int blockbit, int *oudata)
|
||
{
|
||
vc_hw_fft(data, blockbit, oudata, 0, data == oudata ? 1 : 0);
|
||
}
|
||
|
||
void COMPLEX_IFFT_FUN(int *data, int blockbit, int *oudata)
|
||
{
|
||
vc_hw_ifft(data, blockbit, oudata, 0, data == oudata ? 1 : 0);
|
||
}
|
||
|
||
static const int real_fft_test_input_data_512[] = {
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 20, -83, 58, -40, 140, -161, 110, -102, 80, -17, 41, -101, 26, 35, -54, -28, 180, -49, -180, 87, 70, 34, -222, 272, -129, 2, 44, 86, -186, 84, 32, -99, 126, -90, 44, -44, 94, -167, 55, 42, 1, -55, 65, -15, -79, 156, -64, -29, 9, 99, -125, -10, 133, -88, -6, 0, 5, 38, -65, 25, -64, 104, -79, -10, 28, -50, 105, -89, 92, -125, 159, -143, 27, 41, -25, 56, -135, 134, -108, 87, -26, 0, -35, 62, 18, -83, 41, 42, -66, -1, 69, -54, -14, 26, 48, -64, 5, 38, -4, -44, 74, -59, 10, 24, 1, -40, 23, 31, -81, 58, -2, -10, 0, 26, -44, 2, 25, -1, -30, 37, -27, 0, 5, 8, -13, -13, 37, -25, 13, -10, 23, -30, 22, -1, -10, 2, 4, -2, -3, 11, -10, 0, 4, 3, -10, 9, -2, -2, -2, 4, -1, -2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||
};
|
||
|
||
static const int real_fft_test_output_data_real_512[] = {
|
||
16, -15, 15, -17, 26, -39, 50, -51, 32, 7, -43, 45, -16, -17, 23, -17, 24, -44, 49, -24, -13, 45, -66, 89, -108, 116, -105, 84, -62, 32, 12, -50, 47, 1, -49, 49, -6, -43, 65, -66, 56, -32, -7, 39, -47, 36, -19, -2, 31, -63, 85, -93, 108, -133, 143, -118, 84, -87, 144, -208, 224, -189, 147, -128, 120, -96, 57, -37, 61, -110, 128, -80, -11, 75, -78, 48, -28, 3, 71, -191, 288, -305, 258, -221, 246, -327, 414, -452, 431, -398, 392, -369, 263, -116, 66, -174, 336, -418, 401, -357, 321, -271, 216, -212, 277, -323, 242, -45, -122, 116, 52, -226, 269, -148, -72, 294, -446, 496, -449, 285, 6, -372, 672, -793, 715, -487, 226, -92, 164, -326, 374, -266, 153, -156, 263, -421, 568, -591, 393, -52, -214, 290, -257, 287, -498, 837, -1075, 991, -594, 77, 383, -612, 327, 521, -1311, 1229, -380, -106, -581, 1888, -2622, 2366, -1699, 1257, -1084, 895, -529, 57, 313, -397, 220, -37, 51, -157, 113, 89, -177, -41, 439, -717, 718, -534, 347, -270, 308, -409, 498, -498, 373, -180, 32, 4, 38, -58, 14, 48, -84, 109, -155, 233, -351, 532, -725, 773, -562, 194, 76, -64, -199, 484, -517, 207, 197, -297, -22, 465, -727, 837, -953, 932, -417, -602, 1538, -1694, 934, 243, -1241, 1793, -1868, 1439, -612, -169, 432, -182, -193, 514, -872, 1058, -524, -755, 1863, -1893, 1041, -279, 131, -279, 279, -114, -20, 88, -168, 270, -355, 420, -474, 507, -516
|
||
};
|
||
|
||
static const int real_fft_test_output_data_img_512[] = {
|
||
0, -5, 14, -22, 29, -28, 16, 9, -34, 43, -20, -21, 43, -30, 3, 9, -11, 30, -72, 111, -127, 123, -115, 104, -81, 46, -12, -11, 29, -44, 44, -10, -43, 70, -40, -19, 53, -42, 11, 18, -44, 66, -68, 41, -3, -31, 52, -72, 86, -85, 73, -67, 68, -59, 29, -5, 23, -75, 105, -72, 3, 49, -60, 55, -65, 83, -80, 49, -17, 34, -102, 172, -181, 123, -49, 3, 29, -85, 150, -164, 99, -11, -22, -23, 100, -146, 128, -66, 22, -23, 28, 6, -32, -55, 252, -417, 433, -339, 248, -200, 166, -132, 130, -154, 123, 18, -207, 293, -212, 59, -11, 151, -404, 636, -750, 718, -573, 374, -153, -62, 203, -174, -50, 381, -688, 861, -833, 633, -438, 418, -536, 604, -526, 389, -308, 327, -484, 777, -1067, 1169, -1061, 910, -887, 1009, -1137, 1074, -736, 284, 1, 27, -367, 1010, -1776, 2123, -1622, 733, -531, 1372, -2304, 2202, -1105, -10, 489, -525, 579, -784, 973, -952, 668, -273, 34, -63, 176, -141, 3, -26, 293, -573, 585, -306, -39, 235, -241, 150, -69, 68, -167, 332, -477, 507, -413, 285, -227, 248, -278, 269, -248, 255, -284, 318, -348, 331, -176, -119, 383, -395, 116, 268, -497, 427, -154, -8, -217, 741, -1159, 1200, -996, 784, -512, -6, 604, -725, 8, 1224, -2201, 2400, -1873, 961, 80, -1027, 1537, -1407, 919, -605, 653, -883, 1299, -2131, 3144, -3489, 2686, -1398, 712, -893, 1285, -1333, 1126, -971, 908, -817, 681, -553, 442, -328, 215, -108, 0
|
||
};
|
||
|
||
static const int complex_fft_test_output_data_256[] = {
|
||
65280, 65536, -21115, 20602, -10685, 10172, -7207, 6694, -5467, 4955, -4423, 3912, -3727, 3214, -3229, 2716, -2855, 2343, -2564, 2053, -2332, 1820, -2142, 1629, -1982, 1470, -1847, 1335, -1731, 1220, -1631, 1119, -1543, 1031, -1465, 953, -1396, 884, -1334, 822, -1278, 766, -1227, 716, -1181, 669, -1139, 627, -1100, 588, -1064, 552, -1030, 519, -1000, 488, -972, 459, -944, 432, -919, 407, -896, 384, -874, 362, -853, 341, -833, 322, -814, 303, -797, 286, -781, 268, -764, 252, -749, 237, -735, 223, -721, 209, -708, 196, -695, 183, -683, 171, -671, 160, -660, 149, -650, 138, -639, 127, -629, 117, -620, 107, -610, 98, -601, 89, -593, 81, -584, 72, -576, 64, -568, 56, -560, 48, -553, 41, -546, 33, -539, 27, -532, 20, -525, 13, -518, 6, -512, 0, -506, -6, -500, -13, -494, -18, -488, -24, -482, -30, -477, -35, -471, -41, -466, -46, -461, -51, -456, -56, -451, -61, -446, -66, -441, -71, -436, -76, -432, -80, -427, -85, -423, -90, -418, -94, -414, -98, -410, -103, -405, -107, -401, -111, -397, -115, -393, -119, -389, -123, -385, -127, -381, -131, -377, -135, -373, -139, -370, -143, -366, -146, -362, -150, -358, -154, -355, -157, -351, -161, -348, -164, -344, -168, -340, -171, -337, -175, -334, -178, -331, -182, -327, -185, -324, -189, -320, -192, -317, -195, -313, -199, -310, -202, -307, -205, -304, -208, -301, -212, -297, -215, -294, -218, -291, -221, -288, -224, -284, -228, -281, -231, -278, -234, -275, -237, -272, -241, -269, -243, -265, -247, -262, -250, -259, -253, -256, -256, -253, -259, -250, -262, -247, -265, -243, -269, -241, -272, -237, -275, -234, -278, -231, -281, -228, -284, -224, -288, -221, -291, -218, -294, -215, -297, -212, -301, -208, -304, -205, -307, -202, -310, -199, -313, -195, -317, -192, -320, -189, -324, -185, -327, -182, -331, -178, -334, -175, -337, -171, -340, -168, -344, -164, -348, -161, -351, -157, -355, -154, -358, -150, -362, -146, -366, -143, -370, -139, -373, -135, -377, -131, -381, -127, -385, -123, -389, -119, -393, -115, -397, -111, -401, -107, -405, -103, -410, -98, -414, -94, -418, -90, -423, -85, -427, -80, -432, -76, -436, -71, -441, -66, -446, -61, -451, -56, -456, -51, -461, -46, -466, -41, -471, -35, -477, -30, -482, -24, -488, -18, -494, -13, -500, -6, -506, 0, -512, 6, -518, 13, -525, 20, -532, 27, -539, 33, -546, 41, -553, 48, -560, 56, -568, 64, -576, 72, -584, 81, -593, 89, -601, 98, -610, 107, -620, 117, -629, 127, -639, 138, -650, 149, -660, 160, -671, 171, -683, 183, -695, 196, -708, 209, -721, 223, -735, 237, -749, 252, -764, 268, -781, 286, -797, 303, -814, 322, -833, 341, -853, 362, -874, 384, -896, 407, -919, 432, -944, 459, -972, 488, -1000, 519, -1030, 552, -1064, 588, -1100, 627, -1139, 669, -1181, 716, -1227, 766, -1278, 822, -1334, 884, -1396, 953, -1465, 1031, -1543, 1119, -1631, 1220, -1731, 1335, -1847, 1470, -1982, 1629, -2142, 1820, -2332, 2053, -2564, 2343, -2855, 2716, -3229, 3214, -3727, 3912, -4423, 4955, -5467, 6694, -7207, 10172, -10685, 20602, -21115
|
||
};
|
||
|
||
static const int complex_fft_test_output_data_512[] = {
|
||
261632, 262144, -83954, 82931, -42230, 41204, -28325, 27297, -21369, 20345, -17196, 16168, -14414, 13386, -12426, 11398, -10934, 9909, -9773, 8752, -8844, 7823, -8084, 7063, -7453, 6429, -6917, 5894, -6457, 5433, -6058, 5036, -5711, 4686, -5402, 4379, -5128, 4105, -4883, 3861, -4663, 3638, -4463, 3438, -4283, 3257, -4117, 3090, -3964, 2939, -3824, 2799, -3694, 2670, -3575, 2551, -3463, 2438, -3358, 2335, -3262, 2238, -3172, 2148, -3086, 2062, -3007, 1983, -2931, 1907, -2859, 1835, -2792, 1769, -2729, 1704, -2668, 1644, -2610, 1587, -2556, 1533, -2503, 1481, -2454, 1431, -2406, 1384, -2362, 1338, -2319, 1294, -2277, 1254, -2238, 1214, -2200, 1176, -2163, 1139, -2128, 1104, -2095, 1070, -2062, 1038, -2030, 1006, -2001, 976, -1971, 947, -1943, 919, -1915, 892, -1890, 866, -1864, 840, -1839, 815, -1815, 792, -1792, 769, -1770, 746, -1748, 724, -1727, 703, -1706, 682, -1687, 662, -1667, 643, -1648, 624, -1630, 606, -1612, 588, -1594, 571, -1578, 554, -1561, 537, -1545, 521, -1529, 505, -1514, 490, -1499, 475, -1484, 461, -1470, 446, -1456, 432, -1442, 419, -1429, 405, -1416, 391, -1403, 378, -1391, 366, -1378, 354, -1366, 342, -1355, 330, -1343, 319, -1332, 308, -1321, 296, -1310, 286, -1299, 275, -1289, 265, -1278, 254, -1269, 244, -1259, 234, -1248, 225, -1239, 215, -1230, 206, -1220, 196, -1211, 188, -1202, 178, -1193, 170, -1185, 161, -1176, 153, -1168, 144, -1160, 136, -1152, 128, -1144, 120, -1136, 112, -1128, 104, -1121, 96, -1113, 89, -1105, 82, -1099, 74, -1091, 67, -1084, 60, -1077, 53, -1070, 46, -1063, 39, -1057, 33, -1050, 26, -1043, 19, -1037, 13, -1030, 6, -1024, 0, -1018, -6, -1012, -12, -1006, -19, -1000, -25, -994, -31, -988, -36, -982, -43, -976, -48, -970, -54, -965, -59, -959, -65, -954, -70, -948, -76, -943, -81, -938, -87, -932, -92, -927, -97, -922, -102, -917, -107, -912, -113, -906, -118, -901, -123, -897, -128, -892, -132, -887, -138, -882, -142, -878, -147, -873, -151, -868, -156, -864, -161, -859, -165, -854, -170, -850, -175, -845, -179, -841, -183, -836, -188, -832, -192, -827, -197, -823, -201, -819, -205, -815, -209, -811, -213, -806, -218, -802, -222, -798, -226, -794, -230, -790, -234, -786, -238, -782, -243, -778, -246, -774, -251, -770, -254, -766, -258, -762, -262, -758, -266, -754, -270, -750, -274, -747, -278, -743, -281, -739, -285, -735, -289, -731, -293, -728, -296, -724, -300, -720, -304, -717, -307, -713, -311, -709, -315, -706, -318, -702, -322, -699, -325, -695, -329, -692, -332, -688, -336, -685, -339, -681, -343, -678, -346, -674, -350, -671, -353, -667, -357, -664, -360, -660, -364, -657, -367, -654, -370, -650, -374, -647, -377, -643, -381, -640, -384, -637, -387, -634, -390, -630, -394, -627, -397, -624, -400, -621, -404, -617, -407, -614, -410, -611, -414, -607, -417, -604, -420, -601, -423, -598, -427, -594, -430, -591, -433, -588, -436, -585, -439, -582, -442, -578, -445, -575, -449, -572, -452, -569, -455, -566, -458, -562, -462, -559, -465, -556, -468, -553, -471, -550, -474, -547, -478, -543, -481, -540, -484, -537, -487, -534, -490, -531, -493, -528, -496, -525, -499, -521, -503, -518, -506, -515, -509, -512, -512, -509, -515, -506, -518, -503, -521, -499, -525, -496, -528, -493, -531, -490, -534, -487, -537, -484, -540, -481, -543, -478, -547, -474, -550, -471, -553, -468, -556, -465, -559, -462, -562, -458, -566, -455, -569, -452, -572, -449, -575, -445, -578, -442, -582, -439, -585, -436, -588, -433, -591, -430, -594, -427, -598, -423, -601, -420, -604, -417, -607, -414, -611, -410, -614, -407, -617, -404, -621, -400, -624, -397, -627, -394, -630, -390, -634, -387, -637, -384, -640, -381, -643, -377, -647, -374, -650, -370, -654, -367, -657, -364, -660, -360, -664, -357, -667, -353, -671, -350, -674, -346, -678, -343, -681, -339, -685, -336, -688, -332, -692, -329, -695, -325, -699, -322, -702, -318, -706, -315, -709, -311, -713, -307, -717, -304, -720, -300, -724, -296, -728, -293, -731, -289, -735, -285, -739, -281, -743, -278, -747, -274, -750, -270, -754, -266, -758, -262, -762, -258, -766, -254, -770, -251, -774, -246, -778, -243, -782, -238, -786, -234, -790, -230, -794, -226, -798, -222, -802, -218, -806, -213, -811, -209, -815, -205, -819, -201, -823, -197, -827, -192, -832, -188, -836, -183, -841, -179, -845, -175, -850, -170, -854, -165, -859, -161, -864, -156, -868, -151, -873, -147, -878, -142, -882, -138, -887, -132, -892, -128, -897, -123, -901, -118, -906, -113, -912, -107, -917, -102, -922, -97, -927, -92, -932, -87, -938, -81, -943, -76, -948, -70, -954, -65, -959, -59, -965, -54, -970, -48, -976, -43, -982, -36, -988, -31, -994, -25, -1000, -19, -1006, -12, -1012, -6, -1018, 0, -1024, 6, -1030, 13, -1037, 19, -1043, 26, -1050, 33, -1057, 39, -1063, 46, -1070, 53, -1077, 60, -1084, 67, -1091, 74, -1099, 82, -1105, 89, -1113, 96, -1121, 104, -1128, 112, -1136, 120, -1144, 128, -1152, 136, -1160, 144, -1168, 153, -1176, 161, -1185, 170, -1193, 178, -1202, 188, -1211, 196, -1220, 206, -1230, 215, -1239, 225, -1248, 234, -1259, 244, -1269, 254, -1278, 265, -1289, 275, -1299, 286, -1310, 296, -1321, 308, -1332, 319, -1343, 330, -1355, 342, -1366, 354, -1378, 366, -1391, 378, -1403, 391, -1416, 405, -1429, 419, -1442, 432, -1456, 446, -1470, 461, -1484, 475, -1499, 490, -1514, 505, -1529, 521, -1545, 537, -1561, 554, -1578, 571, -1594, 588, -1612, 606, -1630, 624, -1648, 643, -1667, 662, -1687, 682, -1706, 703, -1727, 724, -1748, 746, -1770, 769, -1792, 792, -1815, 815, -1839, 840, -1864, 866, -1890, 892, -1915, 919, -1943, 947, -1971, 976, -2001, 1006, -2030, 1038, -2062, 1070, -2095, 1104, -2128, 1139, -2163, 1176, -2200, 1214, -2238, 1254, -2277, 1294, -2319, 1338, -2362, 1384, -2406, 1431, -2454, 1481, -2503, 1533, -2556, 1587, -2610, 1644, -2668, 1704, -2729, 1769, -2792, 1835, -2859, 1907, -2931, 1983, -3007, 2062, -3086, 2148, -3172, 2238, -3262, 2335, -3358, 2438, -3463, 2551, -3575, 2670, -3694, 2799, -3824, 2939, -3964, 3090, -4117, 3257, -4283, 3438, -4463, 3638, -4663, 3861, -4883, 4105, -5128, 4379, -5402, 4686, -5711, 5036, -6058, 5433, -6457, 5894, -6917, 6429, -7453, 7063, -8084, 7823, -8844, 8752, -9773, 9909, -10934, 11398, -12426, 13386, -14414, 16168, -17196, 20345, -21369, 27297, -28325, 41204, -42230, 82931, -83954
|
||
};
|
||
|
||
static const int real_fft_test_output_data_1024[] = {
|
||
523776, 0, -511, 166887, -514, 83437, -515, 55627, -512, 41720, -516, 33372, -515, 27809, -515, 23835, -512, 20855, -510, 18539, -509, 16683, -509, 15164, -513, 13901, -511, 12831, -512, 11912, -511, 11117, -512, 10422, -511, 9808, -512, 9261, -511, 8774, -513, 8333, -514, 7934, -514, 7575, -514, 7243, -513, 6941, -513, 6662, -512, 6405, -512, 6168, -513, 5945, -512, 5739, -512, 5547, -512, 5369, -512, 5198, -512, 5042, -512, 4891, -512, 4749, -511, 4617, -513, 4491, -512, 4372, -512, 4259, -511, 4151, -511, 4048, -511, 3952, -511, 3857, -511, 3769, -513, 3685, -512, 3603, -512, 3526, -512, 3452, -512, 3380, -512, 3311, -513, 3246, -512, 3182, -512, 3120, -513, 3063, -512, 3006, -512, 2950, -512, 2897, -512, 2847, -512, 2797, -512, 2750, -511, 2704, -512, 2659, -512, 2616, -512, 2574, -512, 2533, -512, 2494, -512, 2456, -512, 2419, -512, 2382, -512, 2348, -512, 2313, -512, 2280, -512, 2248, -511, 2216, -511, 2186, -512, 2156, -512, 2127, -512, 2098, -512, 2071, -512, 2044, -512, 2017, -512, 1993, -512, 1967, -512, 1942, -513, 1918, -513, 1895, -513, 1872, -512, 1850, -512, 1828, -512, 1807, -512, 1786, -513, 1765, -512, 1745, -512, 1726, -512, 1708, -512, 1688, -512, 1670, -512, 1652, -512, 1633, -512, 1616, -512, 1599, -512, 1582, -511, 1566, -512, 1550, -511, 1534, -512, 1518, -511, 1503, -512, 1489, -512, 1474, -512, 1459, -512, 1445, -512, 1431, -512, 1417, -512, 1404, -512, 1390, -512, 1377, -512, 1365, -513, 1351, -512, 1340, -512, 1327, -511, 1315, -512, 1303, -512, 1292, -512, 1281, -512, 1269, -512, 1258, -512, 1247, -512, 1236, -512, 1225, -512, 1215, -512, 1205, -512, 1195, -512, 1184, -512, 1174, -512, 1164, -512, 1155, -512, 1146, -511, 1136, -512, 1127, -512, 1118, -512, 1109, -512, 1100, -512, 1091, -512, 1083, -512, 1074, -512, 1066, -512, 1058, -512, 1049, -512, 1040, -512, 1033, -512, 1025, -512, 1017, -512, 1009, -512, 1002, -512, 994, -512, 987, -512, 979, -512, 973, -512, 965, -512, 958, -512, 951, -512, 944, -512, 937, -512, 930, -512, 923, -512, 917, -512, 911, -512, 904, -512, 897, -512, 891, -512, 885, -512, 878, -512, 872, -512, 866, -512, 860, -512, 854, -512, 848, -512, 842, -512, 837, -512, 831, -512, 825, -512, 819, -512, 814, -512, 808, -512, 803, -512, 798, -512, 792, -512, 787, -512, 782, -512, 776, -512, 771, -512, 766, -512, 761, -512, 756, -512, 751, -512, 746, -512, 741, -512, 737, -512, 732, -512, 727, -512, 722, -512, 718, -512, 713, -512, 708, -512, 704, -512, 699, -512, 695, -512, 690, -512, 686, -512, 681, -512, 677, -512, 673, -512, 668, -512, 664, -512, 660, -512, 656, -512, 652, -512, 648, -512, 644, -512, 640, -512, 636, -512, 632, -512, 628, -512, 624, -512, 620, -512, 616, -512, 612, -512, 608, -512, 605, -512, 601, -512, 597, -512, 594, -512, 590, -512, 586, -512, 583, -512, 579, -512, 575, -512, 572, -512, 568, -512, 565, -512, 561, -512, 558, -512, 555, -512, 551, -512, 548, -512, 544, -512, 541, -512, 538, -512, 534, -512, 531, -512, 528, -512, 525, -512, 522, -512, 518, -512, 515, -512, 512, -512, 509, -512, 506, -512, 503, -512, 500, -512, 496, -512, 493, -512, 490, -512, 487, -512, 485, -512, 482, -512, 479, -512, 476, -512, 473, -512, 470, -512, 467, -512, 464, -512, 461, -512, 458, -512, 456, -512, 453, -512, 450, -512, 447, -512, 444, -512, 442, -512, 439, -512, 436, -512, 434, -512, 431, -512, 428, -512, 426, -512, 423, -512, 420, -512, 418, -512, 415, -512, 412, -512, 410, -512, 407, -512, 405, -512, 402, -512, 400, -512, 397, -512, 395, -512, 392, -512, 390, -512, 387, -512, 385, -512, 382, -512, 380, -512, 377, -512, 375, -512, 372, -512, 370, -512, 368, -512, 365, -512, 363, -512, 361, -512, 358, -512, 356, -512, 354, -512, 351, -512, 349, -512, 347, -512, 344, -512, 342, -512, 340, -512, 338, -512, 335, -512, 333, -512, 331, -512, 329, -512, 326, -512, 324, -512, 322, -512, 320, -512, 318, -512, 316, -512, 313, -512, 311, -512, 309, -512, 307, -512, 305, -512, 303, -512, 301, -512, 298, -512, 296, -512, 294, -512, 292, -512, 290, -512, 288, -512, 286, -512, 284, -512, 282, -512, 280, -512, 278, -512, 276, -512, 274, -512, 272, -512, 270, -512, 268, -512, 266, -512, 264, -512, 262, -512, 260, -512, 258, -512, 256, -512, 254, -512, 252, -512, 250, -512, 248, -512, 246, -512, 244, -512, 242, -512, 240, -512, 238, -512, 236, -512, 235, -512, 233, -512, 230, -512, 229, -512, 227, -512, 225, -512, 223, -512, 221, -512, 220, -512, 218, -512, 216, -512, 214, -512, 212, -512, 210, -512, 208, -512, 207, -512, 205, -512, 203, -512, 201, -512, 199, -512, 198, -512, 196, -512, 194, -512, 192, -512, 190, -512, 189, -512, 187, -512, 185, -512, 183, -512, 182, -512, 180, -512, 178, -512, 176, -512, 174, -512, 173, -512, 171, -512, 169, -512, 167, -512, 166, -512, 164, -512, 162, -512, 160, -512, 159, -512, 157, -512, 155, -512, 154, -512, 152, -512, 150, -512, 149, -512, 147, -512, 145, -512, 143, -512, 142, -512, 140, -512, 139, -512, 137, -512, 135, -512, 133, -512, 132, -512, 130, -512, 128, -512, 127, -512, 125, -512, 123, -512, 122, -512, 120, -512, 118, -512, 117, -512, 115, -512, 113, -512, 112, -512, 110, -512, 108, -512, 107, -512, 105, -512, 104, -512, 102, -512, 100, -512, 99, -512, 97, -512, 95, -512, 94, -512, 92, -512, 90, -512, 89, -512, 87, -512, 86, -512, 84, -512, 82, -512, 81, -512, 79, -512, 78, -512, 76, -512, 74, -512, 73, -512, 71, -512, 70, -512, 68, -512, 66, -512, 65, -512, 63, -512, 62, -512, 60, -512, 58, -512, 57, -512, 55, -512, 54, -512, 52, -512, 50, -512, 49, -512, 47, -512, 46, -512, 44, -512, 43, -512, 41, -512, 39, -512, 38, -512, 36, -512, 35, -512, 33, -512, 32, -512, 30, -512, 28, -512, 27, -512, 25, -512, 24, -512, 22, -512, 20, -512, 19, -512, 17, -512, 16, -512, 14, -512, 13, -512, 11, -512, 9, -512, 8, -512, 6, -512, 5, -512, 3, -512, 2, -512, 0
|
||
};
|
||
|
||
SEC_USED(.fft_data) static int test_datain[4096];
|
||
SEC_USED(.fft_data) static int test_dataout[4096];
|
||
SEC_USED(.fft_data) static fft_config_struct test_fft_config;
|
||
|
||
___interrupt
|
||
static void fft_isr(void)
|
||
{
|
||
if (JL_FFT->CON & BIT(7)) {
|
||
|
||
}
|
||
}
|
||
|
||
static void hw_fft_test(void)
|
||
{
|
||
#if 0
|
||
REAL_FFT_FUN(datain, 7, datain); //输入数据为128个实数，放在datain,输出数据是65个复数，排布为实部，虚部，实部，虚部。。。
|
||
puts("REAL_FFT_FUN RES:\n");
|
||
for (int i = 0; i < sizeof(datain) / sizeof(datain[0]); i++) {
|
||
printf("%d, ", datain[i]);
|
||
}
|
||
|
||
REAL_IFFT_FUN(datain, 7, dataout); //反变换，得到128个实数
|
||
puts("REAL_IFFT_FUN RES:\n");
|
||
for (int i = 0; i < sizeof(dataout) / sizeof(dataout[0]); i++) {
|
||
printf("%d, ", dataout[i]);
|
||
}
|
||
|
||
COMPLEX_FFT_FUN(datain, 6, datain); //输入数据为64个复数，放在datain,输出数据是64个复数，排布为实部，虚部，实部，虚部。。。
|
||
puts("COMPLEX_FFT_FUN RES:\n");
|
||
for (int i = 0; i < sizeof(datain) / sizeof(datain[0]); i++) {
|
||
printf("%d, ", datain[i]);
|
||
}
|
||
|
||
COMPLEX_IFFT_FUN(datain, 6, dataout); //反变换，得到64个复数
|
||
puts("COMPLEX_IFFT_FUN RES:\n");
|
||
for (int i = 0; i < sizeof(dataout) / sizeof(dataout[0]); i++) {
|
||
printf("%d, ", dataout[i]);
|
||
}
|
||
#endif
|
||
|
||
/* request_irq(IRQ_FFT_IDX, 0, fft_isr, 0); */
|
||
|
||
static u8 fft_test_cnt = 0;
|
||
int *out_ptr = NULL;
|
||
|
||
if (fft_test_cnt++ % 2) {
|
||
out_ptr = test_datain;
|
||
} else {
|
||
out_ptr = test_dataout;
|
||
}
|
||
|
||
if (fft_test_cnt == 64) {
|
||
fft_test_cnt = 0;
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, REAL_FFT512_CONFIG, (long *)test_datain, (long *)out_ptr);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(real_fft_test_input_data_512); i++) {
|
||
test_datain[i] = real_fft_test_input_data_512[i];
|
||
}
|
||
|
||
hwfft_fft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(real_fft_test_input_data_512) + 2; i++) {
|
||
/* printf("%d, ", out_ptr[i]); */
|
||
if (i % 2 == 0 && out_ptr[i] != real_fft_test_output_data_real_512[i / 2]) {
|
||
___trig;
|
||
printf("fft test real fail !!!\n");
|
||
put_buf((u8 *)out_ptr, sizeof(real_fft_test_input_data_512) + 8);
|
||
while (1);
|
||
} else if (i % 2 && out_ptr[i] != real_fft_test_output_data_img_512[i / 2]) {
|
||
___trig;
|
||
printf("fft test img fail !!!\n");
|
||
put_buf((u8 *)out_ptr, sizeof(real_fft_test_input_data_512) + 8);
|
||
while (1);
|
||
}
|
||
}
|
||
|
||
if (out_ptr != test_datain) {
|
||
memset(test_datain, 0, sizeof(test_datain));
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, REAL_IFFT512_CONFIG, (long *)out_ptr, (long *)test_datain);
|
||
|
||
hwfft_ifft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(real_fft_test_input_data_512); i++) {
|
||
/* printf("%d, ", test_datain[i]); */
|
||
if (test_datain[i] != real_fft_test_input_data_512[i]) {
|
||
___trig;
|
||
printf("ifft test real fail !!!\n");
|
||
put_buf((u8 *)test_datain, sizeof(real_fft_test_input_data_512));
|
||
while (1);
|
||
}
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, COMPLEX_FFT256_CONFIG, (long *)test_datain, (long *)out_ptr);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(complex_fft_test_output_data_256); i++) {
|
||
test_datain[i] = i;
|
||
}
|
||
|
||
hwfft_fft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(complex_fft_test_output_data_256); i++) {
|
||
/* printf("%d, ", out_ptr[i]); */
|
||
if (out_ptr[i] != complex_fft_test_output_data_256[i]) {
|
||
___trig;
|
||
printf("fft test complex fail !!!\n");
|
||
put_buf((u8 *)out_ptr, sizeof(complex_fft_test_output_data_256));
|
||
while (1);
|
||
}
|
||
}
|
||
|
||
if (out_ptr != test_datain) {
|
||
memset(test_datain, 0, sizeof(test_datain));
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, COMPLEX_IFFT256_CONFIG, (long *)out_ptr, (long *)test_datain);
|
||
|
||
hwfft_ifft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(complex_fft_test_output_data_256); i++) {
|
||
/* printf("%d, ", test_datain[i]); */
|
||
if (test_datain[i] != i) {
|
||
___trig;
|
||
printf("ifft test complex fail !!!\n");
|
||
put_buf((u8 *)test_datain, sizeof(complex_fft_test_output_data_256));
|
||
while (1);
|
||
}
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, COMPLEX_FFT512_CONFIG, (long *)test_datain, (long *)out_ptr);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(complex_fft_test_output_data_512); i++) {
|
||
test_datain[i] = i;
|
||
}
|
||
|
||
hwfft_fft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(complex_fft_test_output_data_512); i++) {
|
||
/* printf("%d, ", out_ptr[i]); */
|
||
if (out_ptr[i] != complex_fft_test_output_data_512[i]) {
|
||
___trig;
|
||
printf("fft test complex fail !!!\n");
|
||
put_buf((u8 *)out_ptr, sizeof(complex_fft_test_output_data_512));
|
||
while (1);
|
||
}
|
||
}
|
||
|
||
if (out_ptr != test_datain) {
|
||
memset(test_datain, 0, sizeof(test_datain));
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, COMPLEX_IFFT512_CONFIG, (long *)out_ptr, (long *)test_datain);
|
||
|
||
hwfft_ifft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(complex_fft_test_output_data_512); i++) {
|
||
/* printf("%d, ", test_datain[i]); */
|
||
if (test_datain[i] != i) {
|
||
___trig;
|
||
printf("ifft test complex fail !!!\n");
|
||
put_buf((u8 *)test_datain, sizeof(complex_fft_test_output_data_512));
|
||
while (1);
|
||
}
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, REAL_FFT1024_CONFIG, (long *)test_datain, (long *)out_ptr);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(real_fft_test_output_data_1024) - 2; i++) {
|
||
test_datain[i] = i;
|
||
}
|
||
|
||
hwfft_fft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(real_fft_test_output_data_1024); i++) {
|
||
/* printf("%d, ", out_ptr[i]); */
|
||
if (out_ptr[i] != real_fft_test_output_data_1024[i]) {
|
||
___trig;
|
||
printf("fft test complex fail !!!\n");
|
||
put_buf((u8 *)out_ptr, sizeof(real_fft_test_output_data_1024));
|
||
while (1);
|
||
}
|
||
}
|
||
|
||
if (out_ptr != test_datain) {
|
||
memset(test_datain, 0, sizeof(test_datain));
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, REAL_IFFT1024_CONFIG, (long *)out_ptr, (long *)test_datain);
|
||
|
||
hwfft_ifft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < ARRAY_SIZE(real_fft_test_output_data_1024) - 2; i++) {
|
||
/* printf("%d, ", test_datain[i]); */
|
||
if (test_datain[i] != i) {
|
||
___trig;
|
||
printf("ifft test complex fail !!!\n");
|
||
put_buf((u8 *)test_datain, sizeof(real_fft_test_output_data_1024) - 2);
|
||
while (1);
|
||
}
|
||
}
|
||
|
||
//循环测试
|
||
for (int n = 0; n < ARRAY_SIZE(real_tab); n += 2) {
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, real_tab[n].config, (long *)test_datain, (long *)out_ptr);
|
||
|
||
for (int i = 0; i < real_tab[n].block; i++) {
|
||
test_datain[i] = i * fft_test_cnt;
|
||
}
|
||
|
||
hwfft_fft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
if (out_ptr != test_datain) {
|
||
memset(test_datain, 0, sizeof(test_datain));
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, real_tab[n + 1].config, (long *)out_ptr, (long *)test_datain);
|
||
|
||
hwfft_ifft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < real_tab[n + 1].block; i++) {
|
||
/* printf("%d, ", test_datain[i]); */
|
||
if (test_datain[i] != i * fft_test_cnt && test_datain[i] != i * fft_test_cnt + 1 && test_datain[i] != i * fft_test_cnt - 1) {
|
||
___trig;
|
||
printf("real test fail n : %d, i : %d, cnt : %d !!!\n", n, i, fft_test_cnt);
|
||
for (int i = 0; i < real_tab[n + 1].block; i++) {
|
||
printf("%d, ", test_datain[i]);
|
||
}
|
||
/* put_buf((u8 *)test_datain, real_tab[n + 1].block * 4); */
|
||
while (1);
|
||
}
|
||
}
|
||
}
|
||
|
||
for (int n = 0; n < ARRAY_SIZE(complex_tab); n += 2) {
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, complex_tab[n].config, (long *)test_datain, (long *)out_ptr);
|
||
|
||
for (int i = 0; i < complex_tab[n].block * 2; i++) {
|
||
test_datain[i] = i;
|
||
}
|
||
|
||
hwfft_fft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
if (out_ptr != test_datain) {
|
||
memset(test_datain, 0, sizeof(test_datain));
|
||
}
|
||
|
||
hwfft_fill_fft_ctx((hwfft_ctx_t *)&test_fft_config, complex_tab[n + 1].config, (long *)out_ptr, (long *)test_datain);
|
||
|
||
hwfft_ifft_i32((hwfft_ctx_t *)&test_fft_config);
|
||
|
||
for (int i = 0; i < complex_tab[n + 1].block * 2; i++) {
|
||
/* printf("%d, ", test_datain[i]); */
|
||
if (test_datain[i] != i) {
|
||
___trig;
|
||
printf("complex test fail n : %d, i : %d, cnt : %d !!!\n", n, i, 2);
|
||
for (int i = 0; i < real_tab[n + 1].block * 2; i++) {
|
||
printf("%d, ", test_datain[i]);
|
||
}
|
||
/* put_buf((u8 *)test_datain, complex_tab[n + 1].block * 2 * 4); */
|
||
while (1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static void fft_test_task(void *priv)
|
||
{
|
||
while (1) {
|
||
hw_fft_test();
|
||
os_time_dly(1);
|
||
}
|
||
}
|
||
|
||
static int fft_test_init(void)
|
||
{
|
||
return thread_fork("fft_test", 0, 256, 0, 0, fft_test_task, NULL);
|
||
}
|
||
late_initcall(fft_test_init);
|
||
|
||
#endif
|
||
|