dsps_fft2r_fc32_ansi.c File Reference

#include "dsps_fft2r.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_fft2r_fc32_ansi.c:

Go to the source code of this file.

Functions
unsigned short	reverse (unsigned short x, unsigned short N, int order)
esp_err_t	dsps_fft2r_init_fc32 (float *fft_table_buff, int table_size)
	init fft tables
void	dsps_fft2r_deinit_fc32 ()
	deinit fft tables
esp_err_t	dsps_fft2r_fc32_ansi_ (float *data, int N, float *w)
	complex FFT of radix 2
esp_err_t	dsps_bit_rev_fc32_ansi (float *data, int N)
	bit reverse operation for the complex input array
esp_err_t	dsps_gen_w_r2_fc32 (float *w, int N)
	Generate coefficients table for the FFT radix 2.
esp_err_t	dsps_cplx2reC_fc32_ansi (float *data, int N)
	Convert complex array to two real arrays.
esp_err_t	dsps_gen_bitrev2r_table (int N, int step, char *name_ext)
esp_err_t	dsps_bit_rev2r_fc32 (float *data, int N)
esp_err_t	dsps_bit_rev_lookup_fc32_ansi (float *data, int reverse_size, uint16_t *reverse_tab)

Variables
static const char *	TAG = "fftr2_ansi"
float *	dsps_fft_w_table_fc32
int	dsps_fft_w_table_size
uint8_t	dsps_fft2r_initialized = 0
uint8_t	dsps_fft2r_mem_allocated = 0
uint16_t *	dsps_fft2r_ram_rev_table = NULL

Function Documentation

dsps_bit_rev2r_fc32()

esp_err_t dsps_bit_rev2r_fc32	(	float *	data,
		int	N )

Definition at line 303 of file dsps_fft2r_fc32_ansi.c.

{
    uint16_t *table;
    uint16_t  table_size;
    switch (N) {
    case 16:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[0];
        table_size = dsps_fft2r_rev_tables_fc32_size[0];
        break;
    case 32:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[1];
        table_size = dsps_fft2r_rev_tables_fc32_size[1];
        break;
    case 64:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[2];
        table_size = dsps_fft2r_rev_tables_fc32_size[2];
        break;
    case 128:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[3];
        table_size = dsps_fft2r_rev_tables_fc32_size[3];
        break;
    case 256:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[4];
        table_size = dsps_fft2r_rev_tables_fc32_size[4];
        break;
    case 512:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[5];
        table_size = dsps_fft2r_rev_tables_fc32_size[5];
        break;
    case 1024:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[6];
        table_size = dsps_fft2r_rev_tables_fc32_size[6];
        break;
    case 2048:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[7];
        table_size = dsps_fft2r_rev_tables_fc32_size[7];
        break;
    case 4096:
        table = (uint16_t *)dsps_fft2r_rev_tables_fc32[8];
        table_size = dsps_fft2r_rev_tables_fc32_size[8];
        break;
 
    default:
        return dsps_bit_rev_fc32(data, N);
        break;
    }
    return dsps_bit_rev_lookup_fc32(data, table_size, table);
}

References data, dsps_bit_rev_fc32, dsps_bit_rev_lookup_fc32, dsps_fft2r_rev_tables_fc32, dsps_fft2r_rev_tables_fc32_size, and N.

dsps_bit_rev_fc32_ansi()

esp_err_t dsps_bit_rev_fc32_ansi	(	float *	data,
		int	N )

bit reverse operation for the complex input array

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 172 of file dsps_fft2r_fc32_ansi.c.

{
    if (!dsp_is_power_of_two(N)) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
 
    esp_err_t result = ESP_OK;
 
    int j, k;
    float r_temp, i_temp;
    j = 0;
    for (int i = 1; i < (N - 1); i++) {
        k = N >> 1;
        while (k <= j) {
            j -= k;
            k >>= 1;
        }
        j += k;
        if (i < j) {
            r_temp = data[j * 2];
            data[j * 2] = data[i * 2];
            data[i * 2] = r_temp;
            i_temp = data[j * 2 + 1];
            data[j * 2 + 1] = data[i * 2 + 1];
            data[i * 2 + 1] = i_temp;
        }
    }
    return result;
}

References data, dsp_is_power_of_two(), ESP_ERR_DSP_INVALID_LENGTH, ESP_OK, k, and N.

Referenced by dsps_fft2r_init_fc32(), dsps_sfdr_f32(), and dsps_snr_f32().

Here is the call graph for this function:

Here is the caller graph for this function:

dsps_bit_rev_lookup_fc32_ansi()

esp_err_t dsps_bit_rev_lookup_fc32_ansi	(	float *	data,
		int	reverse_size,
		uint16_t *	reverse_tab )

Definition at line 352 of file dsps_fft2r_fc32_ansi.c.

{
    float r_temp, i_temp;
    for (int n = 0 ; n < reverse_size ; n++) {
        uint16_t i = reverse_tab[n * 2 + 0] >> 2;
        uint16_t j = reverse_tab[n * 2 + 1] >> 2;
        r_temp = data[j];
        data[j] = data[i];
        data[i] = r_temp;
        i_temp = data[j + 1];
        data[j + 1] = data[i + 1];
        data[i + 1] = i_temp;
    }
    return ESP_OK;
}

References data, ESP_OK, and n.

dsps_cplx2reC_fc32_ansi()

esp_err_t dsps_cplx2reC_fc32_ansi	(	float *	data,
		int	N )

Convert complex array to two real arrays.

Convert complex array to two real arrays in case if input was two real arrays. This function have to be used if FFT used to process real data. 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. 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], Input2: input[N..2*N-1]
[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 221 of file dsps_fft2r_fc32_ansi.c.

{
    if (!dsp_is_power_of_two(N)) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
    esp_err_t result = ESP_OK;
 
    int i;
    int n2 = N << 1;
 
    float rkl = 0;
    float rkh = 0;
    float rnl = 0;
    float rnh = 0;
    float ikl = 0;
    float ikh = 0;
    float inl = 0;
    float inh = 0;
 
    for (i = 0; i < (N / 4); i++) {
        rkl = data[i * 2 + 0 + 2];
        ikl = data[i * 2 + 1 + 2];
        rnl = data[n2 - i * 2 - 2];
        inl = data[n2 - i * 2 - 1];
 
        rkh = data[i * 2 + 0 + 2 + N];
        ikh = data[i * 2 + 1 + 2 + N];
        rnh = data[n2 - i * 2 - 2 - N];
        inh = data[n2 - i * 2 - 1 - N];
 
        data[i * 2 + 0 + 2] = rkl + rnl;
        data[i * 2 + 1 + 2] = ikl - inl;
 
        data[n2 - i * 2 - 1 - N] = inh - ikh;
        data[n2 - i * 2 - 2 - N] = rkh + rnh;
 
        data[i * 2 + 0 + 2 + N] = ikl + inl;
        data[i * 2 + 1 + 2 + N] = rnl - rkl;
 
        data[n2 - i * 2 - 1] = rkh - rnh;
        data[n2 - i * 2 - 2] = ikh + inh;
    }
    data[N] = data[1];
    data[1] = 0;
    data[N + 1] = 0;
 
    return result;
}

References data, dsp_is_power_of_two(), ESP_ERR_DSP_INVALID_LENGTH, ESP_OK, and N.

Here is the call graph for this function:

dsps_fft2r_deinit_fc32()

void dsps_fft2r_deinit_fc32

(

void

)

deinit fft tables

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

Definition at line 102 of file dsps_fft2r_fc32_ansi.c.

{
    if (dsps_fft2r_mem_allocated) {
#if CONFIG_IDF_TARGET_ESP32S3
        if (dsps_fft_w_table_fc32 != dsps_fft2r_w_table_fc32_1024) {
            free(dsps_fft_w_table_fc32);
        }
#else
        free(dsps_fft_w_table_fc32);
#endif
    }
    if (dsps_fft2r_ram_rev_table != NULL) {
        free(dsps_fft2r_ram_rev_table);
        dsps_fft2r_ram_rev_table = NULL;
    }
    // Re init bitrev table for next use
    dsps_fft2r_rev_tables_init_fc32();
    dsps_fft2r_mem_allocated = 0;
    dsps_fft2r_initialized = 0;
}

References dsps_fft2r_initialized, dsps_fft2r_mem_allocated, dsps_fft2r_ram_rev_table, dsps_fft2r_rev_tables_init_fc32(), and dsps_fft_w_table_fc32.

Here is the call graph for this function:

dsps_fft2r_fc32_ansi_()

esp_err_t dsps_fft2r_fc32_ansi_	(	float *	data,
		int	N,
		float *	w )

complex FFT of radix 2

Complex FFT of radix 2 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]	w	pointer to the sin/cos table

Returns

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

Definition at line 123 of file dsps_fft2r_fc32_ansi.c.

{
    if (!dsp_is_power_of_two(N)) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
    if (!dsps_fft2r_initialized) {
        return ESP_ERR_DSP_UNINITIALIZED;
    }
 
    esp_err_t result = ESP_OK;
 
    int ie, ia, m;
    float re_temp, im_temp;
    float c, s;
    ie = 1;
    for (int N2 = N / 2; N2 > 0; N2 >>= 1) {
        ia = 0;
        for (int j = 0; j < ie; j++) {
            c = w[2 * j];
            s = w[2 * j + 1];
            for (int i = 0; i < N2; i++) {
                m = ia + N2;
                re_temp = c * data[2 * m] + s * data[2 * m + 1];
                im_temp = c * data[2 * m + 1] - s * data[2 * m];
                data[2 * m] = data[2 * ia] - re_temp;
                data[2 * m + 1] = data[2 * ia + 1] - im_temp;
                data[2 * ia] = data[2 * ia] + re_temp;
                data[2 * ia + 1] = data[2 * ia + 1] + im_temp;
                ia++;
            }
            ia += N2;
        }
        ie <<= 1;
    }
    return result;
}

References data, dsp_is_power_of_two(), dsps_fft2r_initialized, ESP_ERR_DSP_INVALID_LENGTH, ESP_ERR_DSP_UNINITIALIZED, ESP_OK, m, and N.

Here is the call graph for this function:

dsps_fft2r_init_fc32()

esp_err_t dsps_fft2r_init_fc32	(	float *	fft_table_buff,
		int	table_size )

init fft tables

Initialization of Complex FFT. 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_fft2r_init_fc32 will allocate buffer internally
[in]	table_size	size of the buffer in float words 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 40 of file dsps_fft2r_fc32_ansi.c.

{
    esp_err_t result = ESP_OK;
    if (dsps_fft2r_initialized != 0) {
        return result;
    }
    if (table_size > CONFIG_DSP_MAX_FFT_SIZE) {
        return ESP_ERR_DSP_PARAM_OUTOFRANGE;
    }
    if (table_size == 0) {
        return result;
    }
    if (fft_table_buff != NULL) {
        if (dsps_fft2r_mem_allocated) {
            return ESP_ERR_DSP_REINITIALIZED;
        }
        dsps_fft_w_table_fc32 = fft_table_buff;
        dsps_fft_w_table_size = table_size;
    } else {
        if (!dsps_fft2r_mem_allocated) {
#if CONFIG_IDF_TARGET_ESP32S3
            if (table_size <= 1024) {
                dsps_fft_w_table_fc32 = dsps_fft2r_w_table_fc32_1024;
            } else {
                dsps_fft_w_table_fc32 = (float *)memalign(16, sizeof(float) * table_size);
            }
#else
            dsps_fft_w_table_fc32 = (float *)malloc(table_size * sizeof(float));
#endif
            if (dsps_fft_w_table_fc32 == NULL) {
                return ESP_ERR_DSP_PARAM_OUTOFRANGE;
            }
        }
        dsps_fft_w_table_size = table_size;
        dsps_fft2r_mem_allocated = 1;
 
    }
 
    // FFT ram_rev table allocated
    int pow = dsp_power_of_two(table_size);
    if ((pow > 3) && (pow < 13)) {
        dsps_fft2r_ram_rev_table = (uint16_t *)malloc(2 * dsps_fft2r_rev_tables_fc32_size[pow - 4] * sizeof(uint16_t));
        if (dsps_fft2r_ram_rev_table == NULL) {
            return ESP_ERR_DSP_PARAM_OUTOFRANGE;
        }
        memcpy(dsps_fft2r_ram_rev_table, dsps_fft2r_rev_tables_fc32[pow - 4], 2 * dsps_fft2r_rev_tables_fc32_size[pow - 4] * sizeof(uint16_t));
        dsps_fft2r_rev_tables_fc32[pow - 4] = dsps_fft2r_ram_rev_table;
    }
 
    result = dsps_gen_w_r2_fc32(dsps_fft_w_table_fc32, dsps_fft_w_table_size);
    if (result != ESP_OK) {
        return result;
    }
    result = dsps_bit_rev_fc32_ansi(dsps_fft_w_table_fc32, dsps_fft_w_table_size >> 1);
    if (result != ESP_OK) {
        return result;
    }
    dsps_fft2r_initialized = 1;
 
    return ESP_OK;
}

References CONFIG_DSP_MAX_FFT_SIZE, dsp_power_of_two(), dsps_bit_rev_fc32_ansi(), dsps_fft2r_initialized, dsps_fft2r_mem_allocated, dsps_fft2r_ram_rev_table, dsps_fft2r_rev_tables_fc32, dsps_fft2r_rev_tables_fc32_size, dsps_fft_w_table_fc32, dsps_fft_w_table_size, dsps_gen_w_r2_fc32(), ESP_ERR_DSP_PARAM_OUTOFRANGE, ESP_ERR_DSP_REINITIALIZED, ESP_OK, and memalign.

Referenced by dsps_sfdr_f32(), dsps_snr_f32(), and test_fft2r().

Here is the call graph for this function:

Here is the caller graph for this function:

dsps_gen_bitrev2r_table()

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

Definition at line 270 of file dsps_fft2r_fc32_ansi.c.

{
    if (!dsp_is_power_of_two(N)) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
 
    int j, k;
    j = 0;
    int items_count = 0;
    ESP_LOGD(TAG, "const uint16_t bitrev2r_table_%i_%s[] = {        ", N, name_ext);
    for (int i = 1; i < (N - 1); i++) {
        k = N >> 1;
        while (k <= j) {
            j -= k;
            k >>= 1;
        }
        j += k;
        if (i < j) {
            ESP_LOGD(TAG, "%i, %i, ", i * step, j * step);
            items_count++;
            if ((items_count % 8) == 0) {
                ESP_LOGD(TAG, " ");
            }
        }
    }
    ESP_LOGD(TAG, "};");
    ESP_LOGD(TAG, "const uint16_t bitrev2r_table_%i_%s_size = %i;\n", N, name_ext, items_count);
 
    ESP_LOGD(TAG, "extern const uint16_t bitrev2r_table_%i_%s[];", N, name_ext);
    ESP_LOGD(TAG, "extern const uint16_t bitrev2r_table_%i_%s_size;\n", N, name_ext);
    return ESP_OK;
}

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

Here is the call graph for this function:

dsps_gen_w_r2_fc32()

esp_err_t dsps_gen_w_r2_fc32	(	float *	w,
		int	N )

Generate coefficients table for the FFT radix 2.

Generate coefficients table for the FFT radix 2. This function called inside init. The implementation use ANSI C and could be compiled and run on any platform

Parameters

[in,out]	w	memory location to store coefficients. By default coefficients will be stored to the dsps_fft_w_table_fc32. Maximum size of the FFT must be setup in menuconfig
[in]	N	maximum size of the FFT that will be used

Returns

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

Definition at line 202 of file dsps_fft2r_fc32_ansi.c.

{
    if (!dsp_is_power_of_two(N)) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
 
    esp_err_t result = ESP_OK;
 
    int i;
    float e = M_PI * 2.0 / N;
 
    for (i = 0; i < (N >> 1); i++) {
        w[2 * i] = cosf(i * e);
        w[2 * i + 1] = sinf(i * e);
    }
 
    return result;
}

References dsp_is_power_of_two(), ESP_ERR_DSP_INVALID_LENGTH, ESP_OK, M_PI, and N.

Referenced by dsps_fft2r_init_fc32().

Here is the call graph for this function:

Here is the caller graph for this function:

reverse()

unsigned short reverse	(	unsigned short	x,
		unsigned short	N,
		int	order )

Definition at line 161 of file dsps_fft2r_fc32_ansi.c.

{
    unsigned short b = x;
 
    b = (b & 0xff00) >> 8 | (b & 0x00fF) << 8;
    b = (b & 0xf0F0) >> 4 | (b & 0x0f0F) << 4;
    b = (b & 0xCCCC) >> 2 | (b & 0x3333) << 2;
    b = (b & 0xAAAA) >> 1 | (b & 0x5555) << 1;
    return b >> (16 - order);
}

References N, and x.

Referenced by dsps_cplx2real_sc16_ansi().

Here is the caller graph for this function:

Variable Documentation

dsps_fft2r_initialized

uint8_t dsps_fft2r_initialized = 0

Definition at line 29 of file dsps_fft2r_fc32_ansi.c.

Referenced by dsps_dct_f32(), dsps_dct_inv_f32(), dsps_dctiv_f32(), dsps_dstiv_f32(), dsps_fft2r_deinit_fc32(), dsps_fft2r_fc32_ansi_(), and dsps_fft2r_init_fc32().

dsps_fft2r_mem_allocated

uint8_t dsps_fft2r_mem_allocated = 0

Definition at line 30 of file dsps_fft2r_fc32_ansi.c.

Referenced by dsps_fft2r_deinit_fc32(), and dsps_fft2r_init_fc32().

dsps_fft2r_ram_rev_table

uint16_t* dsps_fft2r_ram_rev_table = NULL

Definition at line 32 of file dsps_fft2r_fc32_ansi.c.

Referenced by dsps_fft2r_deinit_fc32(), and dsps_fft2r_init_fc32().

dsps_fft_w_table_fc32

float* dsps_fft_w_table_fc32

Definition at line 27 of file dsps_fft2r_fc32_ansi.c.

Referenced by dsps_dct_f32(), dsps_fft2r_deinit_fc32(), dsps_fft2r_init_fc32(), and test_fft2r().

dsps_fft_w_table_size

int dsps_fft_w_table_size

Definition at line 28 of file dsps_fft2r_fc32_ansi.c.

Referenced by dsps_fft2r_init_fc32().

TAG

const char* TAG = "fftr2_ansi"

static

Definition at line 25 of file dsps_fft2r_fc32_ansi.c.