GitHub-Mirror/bl_mcu_sdk
2
0
Fork 0
mirror of https://github.com/Fishwaldo/bl_mcu_sdk.git synced 2025-07-23 13:18:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[feat][nmsis] add nmsis component and nn,dsp demo

Browse source
This commit is contained in:
jzlv 2021-09-26 13:38:51 +08:00
parent b2aada479b
commit 5d1126d0f0
989 changed files with 286224 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

5
examples/dsp/TransformFunction_rfftf32/CMakeLists.txt Normal file
View file

@ -0,0 +1,5 @@
set(TARGET_REQUIRED_PRIVATE_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/..)
set(TARGET_REQUIRED_LIBS nmsis)
list(APPEND TARGET_REQUIRED_SRCS cfft.c rfft.c)
set(mains main.c)
generate_bin()

14
examples/dsp/TransformFunction_rfftf32/array.h Normal file
View file

File diff suppressed because one or more lines are too long

618
examples/dsp/TransformFunction_rfftf32/cfft.c Normal file
View file

@ -0,0 +1,618 @@
#include "riscv_const_structs.h"
#include "ref.h"
void ref_cfft_f32(const riscv_cfft_instance_f32 *S, float32_t *p1,
uint8_t ifftFlag, uint8_t bitReverseFlag)
{
int n, mmax, m, j, istep, i;
float32_t wtemp, wr, wpr, wpi, wi, theta;
float32_t tempr, tempi;
float32_t *data = p1;
uint32_t N = S->fftLen;
int32_t dir = (ifftFlag) ? -1 : 1;
// decrement pointer since the original version used fortran style indexing.
data--;
n = N << 1;
j = 1;
for (i = 1; i < n; i += 2) {
if (j > i) {
tempr = data[j];
data[j] = data[i];
data[i] = tempr;
tempr = data[j + 1];
data[j + 1] = data[i + 1];
data[i + 1] = tempr;
}
m = n >> 1;
while (m >= 2 && j > m) {
j -= m;
m >>= 1;
}
j += m;
}
mmax = 2;
while (n > mmax) {
istep = 2 * mmax;
theta = -6.283185307179586f / (dir * mmax);
wtemp = sinf(0.5f * theta);
wpr = -2.0f * wtemp * wtemp;
wpi = sinf(theta);
wr = 1.0f;
wi = 0.0f;
for (m = 1; m < mmax; m += 2) {
for (i = m; i <= n; i += istep) {
j = i + mmax;
tempr = wr * data[j] - wi * data[j + 1];
tempi = wr * data[j + 1] + wi * data[j];
data[j] = data[i] - tempr;
data[j + 1] = data[i + 1] - tempi;
data[i] += tempr;
data[i + 1] += tempi;
}
wr = (wtemp = wr) * wpr - wi * wpi + wr;
wi = wi * wpr + wtemp * wpi + wi;
}
mmax = istep;
}
// Inverse transform is scaled by 1/N
if (ifftFlag) {
data++;
for (i = 0; i < 2 * N; i++) {
data[i] /= N;
}
}
}
void ref_cfft_q31(const riscv_cfft_instance_q31 *S, q31_t *p1, uint8_t ifftFlag,
uint8_t bitReverseFlag)
{
uint32_t i;
// float32_t *fSrc = (float32_t*)p1;
float32_t fSrc[S->fftLen * 2];
riscv_q31_to_float(p1, fSrc, S->fftLen * 2);
for (i = 0; i < S->fftLen * 2; i++) {
// read the q31 data, cast to float, scale down for float
fSrc[i] = (float32_t)p1[i] / 2147483648.0f;
}
switch (S->fftLen) {
case 16:
ref_cfft_f32(&riscv_cfft_sR_f32_len16, fSrc, ifftFlag,
bitReverseFlag);
break;
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, fSrc, ifftFlag,
bitReverseFlag);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, fSrc, ifftFlag,
bitReverseFlag);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, fSrc, ifftFlag,
bitReverseFlag);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, fSrc, ifftFlag,
bitReverseFlag);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, fSrc, ifftFlag,
bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, fSrc, ifftFlag,
bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, fSrc, ifftFlag,
bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, fSrc, ifftFlag,
bitReverseFlag);
break;
}
if (ifftFlag) {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q31, cast to q31
p1[i] = (q31_t)(fSrc[i] * 2147483648.0f);
}
} else {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q31, cast to q31
p1[i] = (q31_t)(fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_q15(const riscv_cfft_instance_q15 *S, q15_t *pSrc, uint8_t ifftFlag,
uint8_t bitReverseFlag)
{
uint32_t i;
// float32_t *fSrc = (float32_t*)pSrc;
float32_t fSrc[S->fftLen * 2];
riscv_q15_to_float(pSrc, fSrc, S->fftLen * 2);
for (i = 0; i < S->fftLen * 2; i++) {
// read the q15 data, cast to float, scale down for float, place in
// temporary buffer
scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
}
for (i = 0; i < S->fftLen * 2; i++) {
// copy from temp buffer to final buffer
fSrc[i] = scratchArray[i];
}
switch (S->fftLen) {
case 16:
ref_cfft_f32(&riscv_cfft_sR_f32_len16, fSrc, ifftFlag,
bitReverseFlag);
break;
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, fSrc, ifftFlag,
bitReverseFlag);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, fSrc, ifftFlag,
bitReverseFlag);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, fSrc, ifftFlag,
bitReverseFlag);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, fSrc, ifftFlag,
bitReverseFlag);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, fSrc, ifftFlag,
bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, fSrc, ifftFlag,
bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, fSrc, ifftFlag,
bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, fSrc, ifftFlag,
bitReverseFlag);
break;
}
if (ifftFlag) {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)(fSrc[i] * 32768.0f);
}
} else {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)(fSrc[i] * 32768.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_radix2_f32(const riscv_cfft_radix2_instance_f32 *S, float32_t *pSrc)
{
switch (S->fftLen) {
case 16:
ref_cfft_f32(&riscv_cfft_sR_f32_len16, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
}
}
void ref_cfft_radix2_q31(const riscv_cfft_radix2_instance_q31 *S, q31_t *pSrc)
{
uint32_t i;
// float32_t *fSrc = (float32_t*)pSrc;
float32_t fSrc[S->fftLen * 2];
riscv_q31_to_float(pSrc, fSrc, S->fftLen * 2);
for (i = 0; i < S->fftLen * 2; i++) {
// read the q31 data, cast to float, scale down for float
fSrc[i] = (float32_t)pSrc[i] / 2147483648.0f;
}
switch (S->fftLen) {
case 16:
ref_cfft_f32(&riscv_cfft_sR_f32_len16, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
}
if (S->ifftFlag) {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q31, cast to q31
pSrc[i] = (q31_t)(fSrc[i] * 2147483648.0f);
}
} else {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q31, cast to q31
pSrc[i] = (q31_t)(fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_radix2_q15(const riscv_cfft_radix2_instance_q15 *S, q15_t *pSrc)
{
uint32_t i;
// float32_t *fSrc = (float32_t*)pSrc;
float32_t fSrc[S->fftLen * 2];
riscv_q15_to_float(pSrc, fSrc, S->fftLen * 2);
for (i = 0; i < S->fftLen * 2; i++) {
// read the q15 data, cast to float, scale down for float, place in
// temporary buffer
scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
}
for (i = 0; i < S->fftLen * 2; i++) {
// copy from temp buffer to final buffer
fSrc[i] = scratchArray[i];
}
switch (S->fftLen) {
case 16:
ref_cfft_f32(&riscv_cfft_sR_f32_len16, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
}
if (S->ifftFlag) {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)(fSrc[i] * 32768.0f);
}
} else {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)(fSrc[i] * 32768.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_radix4_f32(const riscv_cfft_radix4_instance_f32 *S, float32_t *pSrc)
{
switch (S->fftLen) {
case 16:
ref_cfft_f32(&riscv_cfft_sR_f32_len16, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, pSrc, S->ifftFlag,
S->bitReverseFlag);
break;
}
}
void ref_cfft_radix4_q31(const riscv_cfft_radix4_instance_q31 *S, q31_t *pSrc)
{
uint32_t i;
// float32_t *fSrc = (float32_t*)pSrc;
float32_t fSrc[S->fftLen * 2];
riscv_q31_to_float(pSrc, fSrc, S->fftLen * 2);
for (i = 0; i < S->fftLen * 2; i++) {
// read the q31 data, cast to float, scale down for float
fSrc[i] = (float32_t)pSrc[i] / 2147483648.0f;
}
switch (S->fftLen) {
case 16:
ref_cfft_f32(&riscv_cfft_sR_f32_len16, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
}
if (S->ifftFlag) {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q31, cast to q31
pSrc[i] = (q31_t)(fSrc[i] * 2147483648.0f);
}
} else {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q31, cast to q31
pSrc[i] = (q31_t)(fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_radix4_q15(const riscv_cfft_radix4_instance_q15 *S, q15_t *pSrc)
{
uint32_t i;
// float32_t *fSrc = (float32_t*)pSrc;
float32_t fSrc[S->fftLen * 2];
riscv_q15_to_float(pSrc, fSrc, S->fftLen * 2);
for (i = 0; i < S->fftLen * 2; i++) {
// read the q15 data, cast to float, scale down for float, place in
// temporary buffer
scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
}
for (i = 0; i < S->fftLen * 2; i++) {
// copy from temp buffer to final buffer
fSrc[i] = scratchArray[i];
}
switch (S->fftLen) {
case 16:
ref_cfft_f32(&riscv_cfft_sR_f32_len16, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, fSrc, S->ifftFlag,
S->bitReverseFlag);
break;
}
if (S->ifftFlag) {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)(fSrc[i] * 32768.0f);
}
} else {
for (i = 0; i < S->fftLen * 2; i++) {
// read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)(fSrc[i] * 32768.0f / (float32_t)S->fftLen);
}
}
}

97
examples/dsp/TransformFunction_rfftf32/main.c Normal file
View file

@ -0,0 +1,97 @@
//
// Created by lujun on 19-6-28.
//
// This contains SIN_COS , clarke, inv_clarke, park, inv_park and pid
// each one has it's own function.
// All function can be found in main function.
// If you don't want to use it, then comment it.
#include "riscv_common_tables.h"
#include "riscv_const_structs.h"
#include "riscv_math.h"
#include "array.h"
#include <stdint.h>
#include "../common.h"
#include "../HelperFunctions/math_helper.c"
#include "../HelperFunctions/ref_helper.c"
#include <stdio.h>
#define DELTAF32 (0.05f)
#define DELTAQ31 (63)
#define DELTAQ15 (1)
#define DELTAQ7 (1)
int test_flag_error = 0;
uint32_t fftSize = 1024;
uint32_t ifftFlag = 0;
uint32_t doBitReverse = 1;
static int DSP_rfft_fast_f32(void)
{
uint16_t i;
/* clang-format off */
riscv_rfft_fast_instance_f32 SS;
/* clang-format on */
riscv_rfft_fast_init_f32(&SS, 512);
BENCH_START(riscv_rfft_fast_f32);
riscv_rfft_fast_f32(&SS, rfft_testinput_f32_50hz_200Hz_fast, f32_testOutput, 0);
BENCH_END(riscv_rfft_fast_f32);
ref_rfft_fast_f32(&SS, rfft_testinput_f32_50hz_200Hz_fast_ref,
f32_testOutput_ref, 0);
float32_t resault, resault_ref;
uint32_t index, index_ref;
riscv_max_f32(f32_testOutput, 512, &resault, &index);
riscv_max_f32(f32_testOutput_ref, 512, &resault_ref, &index_ref);
if (index != index_ref) {
BENCH_ERROR(riscv_rfft_fast_f32);
printf("expect: %d, actual: %d\n", index_ref, index);
test_flag_error = 1;
}
BENCH_STATUS(riscv_rfft_fast_f32);
}
static int DSP_rfft_f32(void)
{
/* clang-format off */
uint16_t i, j;
riscv_rfft_instance_f32 SS;
riscv_cfft_radix4_instance_f32 S_CFFT;
/* clang-format on */
fftSize = 512;
ifftFlag = 0;
doBitReverse = 1;
riscv_cfft_radix4_init_f32(&S_CFFT, 256, ifftFlag, doBitReverse);
riscv_rfft_init_f32(&SS, &S_CFFT, fftSize, ifftFlag, doBitReverse);
BENCH_START(riscv_rfft_f32);
riscv_rfft_f32(&SS, rfft_testinput_f32_50hz_200Hz, f32_testOutput);
BENCH_END(riscv_rfft_f32);
riscv_cfft_radix4_init_f32(&S_CFFT, 256, ifftFlag, doBitReverse);
riscv_rfft_init_f32(&SS, &S_CFFT, fftSize, ifftFlag, doBitReverse);
ref_rfft_f32(&SS, rfft_testinput_f32_50hz_200Hz_ref, f32_testOutput_ref);
float32_t resault, resault_ref;
uint32_t index, index_ref;
riscv_max_f32(f32_testOutput, fftSize, &resault, &index);
riscv_max_f32(f32_testOutput_ref, fftSize, &resault_ref, &index_ref);
if (index != index_ref) {
BENCH_ERROR(riscv_rfft_f32);
printf("expect: %d, actual: %d\n", index_ref, index);
test_flag_error = 1;
}
BENCH_STATUS(riscv_rfft_f32);
}
int main()
{
BENCH_INIT;
DSP_rfft_fast_f32();
DSP_rfft_f32();
BENCH_FINISH;
if (test_flag_error) {
printf("test error apprears, please recheck.\n");
return 1;
} else {
printf("all test are passed. Well done!\n");
}
return 0;
}

276
examples/dsp/TransformFunction_rfftf32/rfft.c Normal file
View file

@ -0,0 +1,276 @@
#include "riscv_const_structs.h"
#include "ref.h"
void ref_rfft_f32(riscv_rfft_instance_f32 *S, float32_t *pSrc, float32_t *pDst)
{
uint32_t i;
if (S->ifftFlagR) {
for (i = 0; i < S->fftLenReal * 2; i++) {
pDst[i] = pSrc[i];
}
} else {
for (i = 0; i < S->fftLenReal; i++) {
pDst[2 * i + 0] = pSrc[i];
pDst[2 * i + 1] = 0.0f;
}
}
switch (S->fftLenReal) {
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, pDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, pDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, pDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 8192:
ref_cfft_f32(&ref_cfft_sR_f32_len8192, pDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
}
if (S->ifftFlagR) {
// throw away the imaginary part which should be all zeros
for (i = 0; i < S->fftLenReal; i++) {
pDst[i] = pDst[2 * i];
}
}
}
void ref_rfft_fast_f32(riscv_rfft_fast_instance_f32 *S, float32_t *p,
float32_t *pOut, uint8_t ifftFlag)
{
uint32_t i, j;
if (ifftFlag) {
for (i = 0; i < S->fftLenRFFT; i++) {
pOut[i] = p[i];
}
// unpack first sample's complex part into middle sample's real part
pOut[S->fftLenRFFT] = pOut[1];
pOut[S->fftLenRFFT + 1] = 0;
pOut[1] = 0;
j = 4;
for (i = S->fftLenRFFT / 2 + 1; i < S->fftLenRFFT; i++) {
pOut[2 * i + 0] = p[2 * i + 0 - j];
pOut[2 * i + 1] = -p[2 * i + 1 - j];
j += 4;
}
} else {
for (i = 0; i < S->fftLenRFFT; i++) {
pOut[2 * i + 0] = p[i];
pOut[2 * i + 1] = 0.0f;
}
}
switch (S->fftLenRFFT) {
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, pOut, ifftFlag, 1);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, pOut, ifftFlag, 1);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, pOut, ifftFlag, 1);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, pOut, ifftFlag, 1);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, pOut, ifftFlag, 1);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, pOut, ifftFlag, 1);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, pOut, ifftFlag, 1);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, pOut, ifftFlag, 1);
break;
}
if (ifftFlag) {
// throw away the imaginary part which should be all zeros
for (i = 0; i < S->fftLenRFFT; i++) {
pOut[i] = pOut[2 * i];
}
} else {
// pack last sample's real part into first sample's complex part
pOut[1] = pOut[S->fftLenRFFT];
}
}
void ref_rfft_q31(const riscv_rfft_instance_q31 *S, q31_t *pSrc, q31_t *pDst)
{
uint32_t i;
// float32_t *fDst = (float32_t*)pDst;
float32_t fDst[S->fftLenReal * 2];
riscv_q31_to_float(pSrc, fDst, S->fftLenReal * 2);
if (S->ifftFlagR) {
for (i = 0; i < S->fftLenReal * 2; i++) {
fDst[i] = (float32_t)pSrc[i] / 2147483648.0f;
}
} else {
for (i = 0; i < S->fftLenReal; i++) {
fDst[2 * i + 0] = (float32_t)pSrc[i] / 2147483648.0f;
fDst[2 * i + 1] = 0.0f;
}
}
switch (S->fftLenReal) {
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 8192:
ref_cfft_f32(&ref_cfft_sR_f32_len8192, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
}
if (S->ifftFlagR) {
// throw away the imaginary part which should be all zeros
for (i = 0; i < S->fftLenReal; i++) {
// read the float data, scale up for q31, cast to q31
pDst[i] = (q31_t)(fDst[2 * i] * 2147483648.0f);
}
} else {
for (i = 0; i < S->fftLenReal; i++) {
// read the float data, scale up for q31, cast to q31
pDst[i] =
(q31_t)(fDst[i] * 2147483648.0f / (float32_t)S->fftLenReal);
}
}
}
void ref_rfft_q15(const riscv_rfft_instance_q15 *S, q15_t *pSrc, q15_t *pDst)
{
uint32_t i;
// float32_t *fDst = (float32_t*)pDst;
float32_t fDst[S->fftLenReal * 2];
riscv_q15_to_float(pSrc, fDst, S->fftLenReal * 2);
if (S->ifftFlagR) {
for (i = 0; i < S->fftLenReal * 2; i++) {
fDst[i] = (float32_t)pSrc[i] / 32768.0f;
}
} else {
for (i = 0; i < S->fftLenReal; i++) {
// read the q15 data, cast to float, scale down for float
fDst[2 * i + 0] = (float32_t)pSrc[i] / 32768.0f;
fDst[2 * i + 1] = 0.0f;
}
}
switch (S->fftLenReal) {
case 32:
ref_cfft_f32(&riscv_cfft_sR_f32_len32, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 64:
ref_cfft_f32(&riscv_cfft_sR_f32_len64, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 128:
ref_cfft_f32(&riscv_cfft_sR_f32_len128, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 256:
ref_cfft_f32(&riscv_cfft_sR_f32_len256, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 512:
ref_cfft_f32(&riscv_cfft_sR_f32_len512, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 1024:
ref_cfft_f32(&riscv_cfft_sR_f32_len1024, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 2048:
ref_cfft_f32(&riscv_cfft_sR_f32_len2048, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 4096:
ref_cfft_f32(&riscv_cfft_sR_f32_len4096, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
case 8192:
ref_cfft_f32(&ref_cfft_sR_f32_len8192, fDst, S->ifftFlagR,
S->bitReverseFlagR);
break;
}
if (S->ifftFlagR) {
// throw away the imaginary part which should be all zeros
for (i = 0; i < S->fftLenReal; i++) {
pDst[i] = (q15_t)(fDst[2 * i] * 32768.0f);
}
} else {
for (i = 0; i < S->fftLenReal; i++) {
pDst[i] = (q15_t)(fDst[i] * 32768.0f / (float32_t)S->fftLenReal);
}
}
}