dsps_fft4r_fc32_ansi.c File Reference

#include "dsps_fft2r.h"
#include "dsps_fft4r.h"
#include "dsp_common.h"
#include "dsp_types.h"
#include <math.h>
#include "esp_attr.h"
#include "esp_log.h"
#include <string.h>
#include <malloc.h>

Include dependency graph for dsps_fft4r_fc32_ansi.c:

Go to the source code of this file.

Functions
esp_err_t	dsps_fft4r_init_fc32 (float *fft_table_buff, int max_fft_size)
	init fft tables
void	dsps_fft4r_deinit_fc32 ()
	deinit fft tables
esp_err_t	dsps_bit_rev4r_direct_fc32_ansi (float *data, int N)
esp_err_t	dsps_fft4r_fc32_ansi_ (float *data, int length, float *table, int table_size)
	complex FFT of radix 4
esp_err_t	dsps_cplx2real_fc32_ansi_ (float *data, int N, float *table, int table_size)
	Convert FFT result to complex array for real input data.
esp_err_t	dsps_gen_bitrev4r_table (int N, int step, char *name_ext)
esp_err_t	dsps_bit_rev4r_fc32 (float *data, int N)
	bit reverse operation for the complex input array radix-4

Variables
static const char *	TAG = "fftr4 ansi"
float *	dsps_fft4r_w_table_fc32
int	dsps_fft4r_w_table_size
uint8_t	dsps_fft4r_initialized = 0
uint8_t	dsps_fft4r_mem_allocated = 0
uint16_t *	dsps_fft4r_ram_rev_table = NULL

Function Documentation

dsps_bit_rev4r_direct_fc32_ansi()

esp_err_t dsps_bit_rev4r_direct_fc32_ansi	(	float *	data,
		int	N )

Definition at line 101 of file dsps_fft4r_fc32_ansi.c.

{
    if (!dsp_is_power_of_two(N)) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
    if (0 == dsps_fft4r_initialized) {
        return ESP_ERR_DSP_UNINITIALIZED;
    }
    esp_err_t result = ESP_OK;
    int log2N = dsp_power_of_two(N);
    int log4N = log2N >> 1;
    if ((log2N & 0x01) != 0) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
    float r_temp, i_temp;
    for (int i = 0; i < N; i++) {
        int cnt;
        int xx;
        int bits2;
        xx = 0;
        cnt = log4N;
        int j = i;
        while (cnt > 0) {
            bits2 = j & 0x3;
            xx = (xx << 2) + bits2;
            j = j >> 2;
            cnt--;
        }
        if (i < xx) {
            r_temp = data[i * 2 + 0];
            i_temp = data[i * 2 + 1];
            data[i * 2 + 0] = data[xx * 2 + 0];
            data[i * 2 + 1] = data[xx * 2 + 1];
            data[xx * 2 + 0] = r_temp;
            data[xx * 2 + 1] = i_temp;
        }
    }
    return result;
}

References data, dsp_is_power_of_two(), dsp_power_of_two(), dsps_fft4r_initialized, ESP_ERR_DSP_INVALID_LENGTH, ESP_ERR_DSP_UNINITIALIZED, ESP_OK, and N.

Referenced by dsps_bit_rev4r_fc32().

Here is the call graph for this function:

Here is the caller graph for this function:

dsps_bit_rev4r_fc32()

esp_err_t dsps_bit_rev4r_fc32	(	float *	data,
		int	N )

bit reverse operation for the complex input array radix-4

Bit reverse operation for the complex input array The implementation use ANSI C and could be compiled and run on any platform

Parameters

[in,out]	data	input/ complex array. An elements located: Re[0], Im[0], ... Re[N-1], Im[N-1] result of FFT will be stored to this array.
[in]	N	Number of complex elements in input array

Returns

• ESP_OK on success
• One of the error codes from DSP library

Definition at line 299 of file dsps_fft4r_fc32_ansi.c.

{
    uint16_t *table;
    uint16_t  table_size;
    switch (N) {
    case 16:
        table = (uint16_t *)dsps_fft4r_rev_tables_fc32[0];
        table_size = dsps_fft4r_rev_tables_fc32_size[0];
        break;
    case 64:
        table = (uint16_t *)dsps_fft4r_rev_tables_fc32[1];
        table_size = dsps_fft4r_rev_tables_fc32_size[1];
        break;
    case 256:
        table = (uint16_t *)dsps_fft4r_rev_tables_fc32[2];
        table_size = dsps_fft4r_rev_tables_fc32_size[2];
        break;
    case 1024:
        table = (uint16_t *)dsps_fft4r_rev_tables_fc32[3];
        table_size = dsps_fft4r_rev_tables_fc32_size[3];
        break;
    case 4096:
        table = (uint16_t *)dsps_fft4r_rev_tables_fc32[4];
        table_size = dsps_fft4r_rev_tables_fc32_size[4];
        break;
 
    default:
        return dsps_bit_rev4r_direct_fc32_ansi(data, N);
        break;
    }
 
    return dsps_bit_rev_lookup_fc32(data, table_size, table);
}

References data, dsps_bit_rev4r_direct_fc32_ansi(), dsps_bit_rev_lookup_fc32, dsps_fft4r_rev_tables_fc32, dsps_fft4r_rev_tables_fc32_size, and N.

Here is the call graph for this function:

dsps_cplx2real_fc32_ansi_()

esp_err_t dsps_cplx2real_fc32_ansi_	(	float *	data,
		int	N,
		float *	table,
		int	table_size )

Convert FFT result to complex array for real input data.

Convert FFT result of complex FFT for real input to complex output. This function have to be used if FFT used to process real data. This function use tabels inside and can be used only it dsps_fft4r_init_fc32(...) was called and FFT4 was initialized. The implementation use ANSI C and could be compiled and run on any platform

Parameters

[in,out]	data	Input complex array and result of FFT2R/FFT4R. input has size of 2*N, because contains real and imaginary part. result will be stored to the same array. Input1: input[0..N-1] if the result is complex Re[0], Im[0]....Re[N-1], Im[N-1], and input[0...2*n-1] if result is real re[0], re[1],...,re[2*N-1].
[in]	N	Number of complex elements in input array
[in]	table	pointer to sin/cos table
[in]	table_size	size of the sin/cos table

Returns

• ESP_OK on success
• One of the error codes from DSP library

Definition at line 218 of file dsps_fft4r_fc32_ansi.c.

{
    if (0 == dsps_fft4r_initialized) {
        return ESP_ERR_DSP_UNINITIALIZED;
    }
    int wind_step = table_size / (N);
    fc32_t *result = (fc32_t *)data;
    // Original formula...
    // result[0].re = result[0].re + result[0].im;
    // result[N].re = result[0].re - result[0].im;
    // result[0].im = 0;
    // result[N].im = 0;
    // Optimized one:
    float tmp_re = result[0].re;
    result[0].re = tmp_re + result[0].im;
    result[0].im = tmp_re - result[0].im;
 
    fc32_t f1k, f2k;
    for (int k = 1; k <= N / 2 ; k++ ) {
        fc32_t fpk = result[k];
        fc32_t fpnk = result[N - k];
        f1k.re = fpk.re + fpnk.re;
        f1k.im = fpk.im - fpnk.im;
        f2k.re = fpk.re - fpnk.re;
        f2k.im = fpk.im + fpnk.im;
 
        float c = -table[k * wind_step + 1];
        float s = -table[k * wind_step + 0];
        fc32_t tw;
        tw.re = c * f2k.re - s * f2k.im;
        tw.im = s * f2k.re + c * f2k.im;
 
        result[k].re = 0.5 * (f1k.re + tw.re);
        result[k].im = 0.5 * (f1k.im + tw.im);
        result[N - k].re = 0.5 * (f1k.re - tw.re);
        result[N - k].im = 0.5 * (tw.im  - f1k.im);
    }
    return ESP_OK;
}

References data, dsps_fft4r_initialized, ESP_ERR_DSP_UNINITIALIZED, ESP_OK, fc32_u::im, k, N, and fc32_u::re.

dsps_fft4r_deinit_fc32()

void dsps_fft4r_deinit_fc32

(

void

)

deinit fft tables

Free resources of Complex FFT Radix-4. This function delete coefficients table if it was allocated by dsps_fft4r_init_fc32. The implementation use ANSI C and could be compiled and run on any platform

Definition at line 85 of file dsps_fft4r_fc32_ansi.c.

{
    if (dsps_fft4r_mem_allocated) {
        free(dsps_fft4r_w_table_fc32);
    }
    if (dsps_fft4r_ram_rev_table != NULL) {
        free(dsps_fft4r_ram_rev_table);
        dsps_fft4r_ram_rev_table = NULL;
    }
    // Re init bitrev table for next use
    dsps_fft4r_rev_tables_init_fc32();
 
    dsps_fft4r_mem_allocated = 0;
    dsps_fft4r_initialized = 0;
}

References dsps_fft4r_initialized, dsps_fft4r_mem_allocated, dsps_fft4r_ram_rev_table, dsps_fft4r_rev_tables_init_fc32(), and dsps_fft4r_w_table_fc32.

Here is the call graph for this function:

dsps_fft4r_fc32_ansi_()

esp_err_t dsps_fft4r_fc32_ansi_	(	float *	data,
		int	N,
		float *	table,
		int	table_size )

complex FFT of radix 4

Complex FFT of radix 4 The extension (_ansi) use ANSI C and could be compiled and run on any platform. The extension (_ae32) is optimized for ESP32 chip.

Parameters

[in,out]	data	input/output complex array. An elements located: Re[0], Im[0], ... Re[N-1], Im[N-1] result of FFT will be stored to this array.
[in]	N	Number of complex elements in input array
[in]	table	pointer to sin/cos table
[in]	table_size	size of the sin/cos table

Returns

• ESP_OK on success
• One of the error codes from DSP library

radix 4

Definition at line 141 of file dsps_fft4r_fc32_ansi.c.

{
    if (0 == dsps_fft4r_initialized) {
        return ESP_ERR_DSP_UNINITIALIZED;
    }
 
    fc32_t bfly[4];
    int log2N = dsp_power_of_two(length);
    int log4N = log2N >> 1;
    if ((log2N & 0x01) != 0) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
 
    int m = 2;
    int wind_step = table_size / length;
    while (1) {  
        if (log4N == 0) {
            break;
        }
        length = length >> 2;
        for (int j = 0; j < m; j += 2) { // j: which FFT of this step
            int start_index = j * (length << 1); // n: n-point FFT
 
            fc32_t *ptrc0 = (fc32_t *)data + start_index;
            fc32_t *ptrc1 = ptrc0 + length;
            fc32_t *ptrc2 = ptrc1 + length;
            fc32_t *ptrc3 = ptrc2 + length;
 
            fc32_t *winc0 = (fc32_t *)table;
            fc32_t *winc1 = winc0;
            fc32_t *winc2 = winc0;
 
            for (int k = 0; k < length; k++) {
                fc32_t in0 = *ptrc0;
                fc32_t in2 = *ptrc2;
                fc32_t in1 = *ptrc1;
                fc32_t in3 = *ptrc3;
 
                bfly[0].re = in0.re + in2.re + in1.re + in3.re;
                bfly[0].im = in0.im + in2.im + in1.im + in3.im;
 
                bfly[1].re = in0.re - in2.re + in1.im - in3.im;
                bfly[1].im = in0.im - in2.im - in1.re + in3.re;
 
                bfly[2].re = in0.re + in2.re - in1.re - in3.re;
                bfly[2].im = in0.im + in2.im - in1.im - in3.im;
 
                bfly[3].re = in0.re - in2.re - in1.im + in3.im;
                bfly[3].im = in0.im - in2.im + in1.re - in3.re;
 
 
 
                *ptrc0 = bfly[0];
                ptrc1->re = bfly[1].re * winc0->re + bfly[1].im * winc0->im;
                ptrc1->im = bfly[1].im * winc0->re - bfly[1].re * winc0->im;
                ptrc2->re = bfly[2].re * winc1->re + bfly[2].im * winc1->im;
                ptrc2->im = bfly[2].im * winc1->re - bfly[2].re * winc1->im;
                ptrc3->re = bfly[3].re * winc2->re + bfly[3].im * winc2->im;
                ptrc3->im = bfly[3].im * winc2->re - bfly[3].re * winc2->im;
 
                winc0 += 1 * wind_step;
                winc1 += 2 * wind_step;
                winc2 += 3 * wind_step;
 
                ptrc0++;
                ptrc1++;
                ptrc2++;
                ptrc3++;
            }
        }
        m = m << 2;
        wind_step = wind_step << 2;
        log4N--;
    }
    return ESP_OK;
}

References data, dsp_power_of_two(), dsps_fft4r_initialized, ESP_ERR_DSP_INVALID_LENGTH, ESP_ERR_DSP_UNINITIALIZED, ESP_OK, fc32_u::im, k, m, and fc32_u::re.

Here is the call graph for this function:

dsps_fft4r_init_fc32()

esp_err_t dsps_fft4r_init_fc32	(	float *	fft_table_buff,
		int	max_fft_size )

init fft tables

Initialization of Complex FFT Radix-4. This function initialize coefficients table. The implementation use ANSI C and could be compiled and run on any platform

Parameters

[in,out]	fft_table_buff	pointer to floating point buffer where sin/cos table will be stored if this parameter set to NULL, and table_size value is more then 0, then dsps_fft4r_init_fc32 will allocate buffer internally
[in]	max_fft_size	maximum fft size. The buffer for sin/cos table that will be used for radix-4 it's four times maximum length of FFT. if fft_table_buff is NULL and table_size is not 0, buffer will be allocated internally. If table_size is 0, buffer will not be allocated.

Returns

• ESP_OK on success
• ESP_ERR_DSP_PARAM_OUTOFRANGE if table_size > CONFIG_DSP_MAX_FFT_SIZE
• ESP_ERR_DSP_REINITIALIZED if buffer already allocated internally by other function
• One of the error codes from DSP library

Definition at line 34 of file dsps_fft4r_fc32_ansi.c.

{
    esp_err_t result = ESP_OK;
    if (dsps_fft4r_initialized != 0) {
        return result;
    }
    if (max_fft_size > CONFIG_DSP_MAX_FFT_SIZE) {
        return ESP_ERR_DSP_PARAM_OUTOFRANGE;
    }
    if (max_fft_size == 0) {
        return result;
    }
    if (fft_table_buff != NULL) {
        if (dsps_fft4r_mem_allocated) {
            return ESP_ERR_DSP_REINITIALIZED;
        }
        dsps_fft4r_w_table_fc32 = fft_table_buff;
        dsps_fft4r_w_table_size = max_fft_size * 2;
    } else {
        if (!dsps_fft4r_mem_allocated) {
            dsps_fft4r_w_table_fc32 = (float *)malloc(max_fft_size * sizeof(float) * 4);
            if (NULL == dsps_fft4r_w_table_fc32) {
                return ESP_ERR_DSP_PARAM_OUTOFRANGE;
            }
        }
        dsps_fft4r_w_table_size = max_fft_size * 2;
        dsps_fft4r_mem_allocated = 1;
    }
 
    // FFT ram_rev table allocated
    int pow = dsp_power_of_two(max_fft_size) >> 1;
    if ((pow >= 2) && (pow <= 6)) {
        dsps_fft4r_ram_rev_table = (uint16_t *)malloc(2 * dsps_fft4r_rev_tables_fc32_size[pow - 2] * sizeof(uint16_t));
        if (NULL == dsps_fft4r_ram_rev_table) {
            return ESP_ERR_DSP_PARAM_OUTOFRANGE;
        }
        memcpy(dsps_fft4r_ram_rev_table, dsps_fft4r_rev_tables_fc32[pow - 2], 2 * dsps_fft4r_rev_tables_fc32_size[pow - 2] * sizeof(uint16_t));
        dsps_fft4r_rev_tables_fc32[pow - 2] = dsps_fft4r_ram_rev_table;
    }
 
    for (int i = 0; i < dsps_fft4r_w_table_size; i++) {
        float angle = 2 * M_PI * i / (float)dsps_fft4r_w_table_size;
        dsps_fft4r_w_table_fc32[2 * i + 0] = cosf(angle);
        dsps_fft4r_w_table_fc32[2 * i + 1] = sinf(angle);
    }
 
    dsps_fft4r_initialized = 1;
 
    return ESP_OK;
}

References CONFIG_DSP_MAX_FFT_SIZE, dsp_power_of_two(), dsps_fft4r_initialized, dsps_fft4r_mem_allocated, dsps_fft4r_ram_rev_table, dsps_fft4r_rev_tables_fc32, dsps_fft4r_rev_tables_fc32_size, dsps_fft4r_w_table_fc32, dsps_fft4r_w_table_size, ESP_ERR_DSP_PARAM_OUTOFRANGE, ESP_ERR_DSP_REINITIALIZED, ESP_OK, and M_PI.

Referenced by app_main().

Here is the call graph for this function:

Here is the caller graph for this function:

dsps_gen_bitrev4r_table()

esp_err_t dsps_gen_bitrev4r_table	(	int	N,
		int	step,
		char *	name_ext )

Definition at line 258 of file dsps_fft4r_fc32_ansi.c.

{
    if (!dsp_is_power_of_two(N)) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
 
    int items_count = 0;
    ESP_LOGD(TAG, "const uint16_t bitrev4r_table_%i_%s[] = {        ", N, name_ext);
    int log2N = dsp_power_of_two(N);
    int log4N = log2N >> 1;
 
    for (int i = 1; i < N - 1; i++) {
        int cnt;
        int xx;
        int bits2;
        xx = 0;
        cnt = log4N;
        int j = i;
        while (cnt > 0) {
            bits2 = j & 0x3;
            xx = (xx << 2) + bits2;
            j = j >> 2;
            cnt--;
        }
        if (i < xx) {
            ESP_LOGD(TAG, "%i, %i, ", i * step, xx * step);
            items_count++;
            if ((items_count % 8) == 0) {
                ESP_LOGD(TAG, "        ");
            }
        }
    }
 
    ESP_LOGD(TAG, "};");
    ESP_LOGD(TAG, "const uint16_t bitrev4r_table_%i_%s_size = %i;\n", N, name_ext, items_count);
 
    ESP_LOGD(TAG, "extern const uint16_t bitrev4r_table_%i_%s[];", N, name_ext);
    ESP_LOGD(TAG, "extern const uint16_t bitrev4r_table_%i_%s_size;\n", N, name_ext);
    return ESP_OK;
}

References dsp_is_power_of_two(), dsp_power_of_two(), ESP_ERR_DSP_INVALID_LENGTH, ESP_LOGD, ESP_OK, N, and TAG.

Here is the call graph for this function:

Variable Documentation

dsps_fft4r_initialized

uint8_t dsps_fft4r_initialized = 0

Definition at line 29 of file dsps_fft4r_fc32_ansi.c.

Referenced by dsps_bit_rev4r_direct_fc32_ansi(), dsps_cplx2real_fc32_ansi_(), dsps_fft4r_deinit_fc32(), dsps_fft4r_fc32_ansi_(), and dsps_fft4r_init_fc32().

dsps_fft4r_mem_allocated

uint8_t dsps_fft4r_mem_allocated = 0

Definition at line 30 of file dsps_fft4r_fc32_ansi.c.

Referenced by dsps_fft4r_deinit_fc32(), and dsps_fft4r_init_fc32().

dsps_fft4r_ram_rev_table

uint16_t* dsps_fft4r_ram_rev_table = NULL

Definition at line 32 of file dsps_fft4r_fc32_ansi.c.

Referenced by dsps_fft4r_deinit_fc32(), and dsps_fft4r_init_fc32().

dsps_fft4r_w_table_fc32

float* dsps_fft4r_w_table_fc32

Definition at line 27 of file dsps_fft4r_fc32_ansi.c.

Referenced by dsps_fft4r_deinit_fc32(), and dsps_fft4r_init_fc32().

dsps_fft4r_w_table_size

int dsps_fft4r_w_table_size

Definition at line 28 of file dsps_fft4r_fc32_ansi.c.

Referenced by dsps_fft4r_init_fc32().

TAG

const char* TAG = "fftr4 ansi"

static

Definition at line 25 of file dsps_fft4r_fc32_ansi.c.