dsps_fir.h File Reference

#include "dsp_err.h"
#include "dsps_fir_platform.h"
#include "dsp_common.h"

Include dependency graph for dsps_fir.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	fir_f32_s
	Data struct of f32 fir filter. More...
struct	fir_s16_s
	Data struct of s16 fir filter. More...

Macros
#define	dsps_fir_f32   dsps_fir_f32_ansi
#define	dsps_fird_f32   dsps_fird_f32_ansi
#define	dsps_firmr_f32   dsps_firmr_f32_ansi
#define	dsps_fird_s16   dsps_fird_s16_ansi
#define	dsps_firmr_s16   dsps_firmr_s16_ansi

Typedefs
typedef struct fir_f32_s	fir_f32_t
	Data struct of f32 fir filter.
typedef struct fir_s16_s	fir_s16_t
	Data struct of s16 fir filter.

Functions
esp_err_t	dsps_fir_init_f32 (fir_f32_t *fir, float *coeffs, float *delay, int coeffs_len)
	initialize structure for 32 bit FIR filter
esp_err_t	dsps_fird_init_f32 (fir_f32_t *fir, float *coeffs, float *delay, int N, int decim)
	initialize structure for 32 bit Decimation FIR filter Function initialize structure for 32 bit floating point FIR filter with decimation The implementation use ANSI C and could be compiled and run on any platform
esp_err_t	dsps_fird_init_s16 (fir_s16_t *fir, int16_t *coeffs, int16_t *delay, int16_t coeffs_len, int16_t decim, int16_t start_pos, int16_t shift)
	initialize structure for 16 bit Decimation FIR filter Function initialize structure for 16 bit signed fixed point FIR filter with decimation The implementation use ANSI C and could be compiled and run on any platform
esp_err_t	dsps_fir_f32_ansi (fir_f32_t *fir, const float *input, float *output, int len)
	32 bit floating point FIR filter
esp_err_t	dsps_fir_f32_ae32 (fir_f32_t *fir, const float *input, float *output, int len)
esp_err_t	dsps_fir_f32_aes3 (fir_f32_t *fir, const float *input, float *output, int len)
int	dsps_fird_f32_ansi (fir_f32_t *fir, const float *input, float *output, int len)
	32 bit floating point Decimation FIR filter
int	dsps_fird_f32_ae32 (fir_f32_t *fir, const float *input, float *output, int len)
int	dsps_fird_f32_aes3 (fir_f32_t *fir, const float *input, float *output, int len)
int	dsps_fird_f32_arp4 (fir_f32_t *fir, const float *input, float *output, int len)
int32_t	dsps_fird_s16_ansi (fir_s16_t *fir, const int16_t *input, int16_t *output, int32_t len)
	16 bit signed fixed point Decimation FIR filter
int32_t	dsps_fird_s16_ae32 (fir_s16_t *fir, const int16_t *input, int16_t *output, int32_t len)
int32_t	dsps_fird_s16_aes3 (fir_s16_t *fir, const int16_t *input, int16_t *output, int32_t len)
int32_t	dsps_fird_s16_arp4 (fir_s16_t *fir, const int16_t *input, int16_t *output, int32_t len)
esp_err_t	dsps_firmr_init_f32 (fir_f32_t *fir, float *coeffs, float *delay, int length, int interp, int decim, int start_pos)
	initialize structure for multi-rate FIR filter Function initialize structure for 32 bit floating point multi-rate FIR filter The implementation use ANSI C and could be compiled and run on any platform
esp_err_t	dsps_firmr_init_s16 (fir_s16_t *fir, int16_t *coeffs, int16_t *delay, int16_t length, int16_t interp, int16_t decim, int16_t start_pos, int16_t shift)
	initialize structure for multi-rate FIR filter Function initialize structure for 16 bit signed fixed point multi-rate FIR filter The implementation use ANSI C and could be compiled and run on any platform
int	dsps_firmr_f32_ansi (fir_f32_t *fir, const float *input, float *output, int input_len)
	32 bit floating point multi-rate FIR filter
int32_t	dsps_firmr_s16_ansi (fir_s16_t *fir, const int16_t *input, int16_t *output, int32_t input_len)
	16 bit signed fixed point multi-rate FIR filter
esp_err_t	dsps_fird_s16_aexx_free (fir_s16_t *fir)
	support arrays freeing function
esp_err_t	dsps_fir_f32_free (fir_f32_t *fir)
	support arrays freeing function
esp_err_t	dsps_16_array_rev (int16_t *arr, int16_t len)
	Array reversal.

Macro Definition Documentation

dsps_fir_f32

#define dsps_fir_f32   dsps_fir_f32_ansi

Definition at line 378 of file dsps_fir.h.

dsps_fird_f32

#define dsps_fird_f32   dsps_fird_f32_ansi

Definition at line 379 of file dsps_fir.h.

dsps_fird_s16

#define dsps_fird_s16   dsps_fird_s16_ansi

Definition at line 381 of file dsps_fir.h.

dsps_firmr_f32

#define dsps_firmr_f32   dsps_firmr_f32_ansi

Definition at line 380 of file dsps_fir.h.

Referenced by dsps_resampler_mr_init().

dsps_firmr_s16

#define dsps_firmr_s16   dsps_firmr_s16_ansi

Definition at line 382 of file dsps_fir.h.

Referenced by dsps_resampler_mr_init().

Typedef Documentation

fir_f32_t

typedef struct fir_f32_s fir_f32_t

Data struct of f32 fir filter.

This structure is used by a filter internally. A user should access this structure only in case of extensions for the DSP Library. All fields of this structure are initialized by the dsps_fir_init_f32(...) function.

fir_s16_t

typedef struct fir_s16_s fir_s16_t

Data struct of s16 fir filter.

This structure is used by a filter internally. A user should access this structure only in case of extensions for the DSP Library. All fields of this structure are initialized by the dsps_fir_init_s16(...) function.

Function Documentation

dsps_16_array_rev()

esp_err_t dsps_16_array_rev	(	int16_t *	arr,
		int16_t	len )

Array reversal.

Function reverses 16-bit long array members for the purpose of the dsps_fird_s16_aes3 implementation The function has to be called either during the fir struct initialization or every time the coefficients change

Parameters

arr	pointer to the array to be reversed
len	length of the array to be reversed

Returns

• ESP_OK on success

Definition at line 146 of file dsps_fird_init_s16.c.

{
 
    int16_t temp;
 
    for (int i = 0; i < (int)(len / 2); i++) {
        temp = arr[i];
        arr[i] = arr[len - 1 - i];
        arr[len - 1 - i] = temp;
    }
    return ESP_OK;
}

References ESP_OK.

dsps_fir_f32_ae32()

esp_err_t dsps_fir_f32_ae32	(	fir_f32_t *	fir,
		const float *	input,
		float *	output,
		int	len )

dsps_fir_f32_aes3()

esp_err_t dsps_fir_f32_aes3	(	fir_f32_t *	fir,
		const float *	input,
		float *	output,
		int	len )

Referenced by test_fir().

Here is the caller graph for this function:

dsps_fir_f32_ansi()

esp_err_t dsps_fir_f32_ansi	(	fir_f32_t *	fir,
		const float *	input,
		float *	output,
		int	len )

32 bit floating point FIR filter

Function implements FIR filter The extension (_ansi) uses ANSI C and could be compiled and run on any platform. The extension (_ae32) is optimized for ESP32 chip.

Parameters

	fir	pointer to fir filter structure, that must be initialized before
[in]	input	input array
[out]	output	array with the result of FIR filter
[in]	len	length of input and result arrays

Returns

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

Definition at line 17 of file dsps_fir_f32_ansi.c.

{
    for (int i = 0 ; i < len ; i++) {
        float acc = 0;
        int coeff_pos = 0;
        fir->delay[fir->pos] = input[i];
        fir->pos++;
        if (fir->pos >= fir->N) {
            fir->pos = 0;
        }
        for (int n = fir->pos; n < fir->N ; n++) {
            acc += fir->coeffs[coeff_pos++] * fir->delay[n];
        }
        for (int n = 0; n < fir->pos ; n++) {
            acc += fir->coeffs[coeff_pos++] * fir->delay[n];
        }
        output[i] = acc;
    }
    return ESP_OK;
}

References fir_f32_s::coeffs, fir_f32_s::delay, ESP_OK, fir_f32_s::N, N, n, and fir_f32_s::pos.

Referenced by test_fir().

Here is the caller graph for this function:

dsps_fir_f32_free()

esp_err_t dsps_fir_f32_free

(

fir_f32_t *

fir

)

support arrays freeing function

Function frees the delay line arrays, if it was allocated by the init functions.

Parameters

fir	pointer to fir filter structure, that must be initialized before

Returns

• ESP_OK on success

Definition at line 60 of file dsps_fir_init_f32.c.

{
    if (fir->use_delay != 0) {
        fir->use_delay = 0;
        free(fir->delay);
    }
    return ESP_OK;
}

References fir_f32_s::delay, ESP_OK, and fir_f32_s::use_delay.

Referenced by dsps_resampler_mr_free().

Here is the caller graph for this function:

dsps_fir_init_f32()

esp_err_t dsps_fir_init_f32	(	fir_f32_t *	fir,
		float *	coeffs,
		float *	delay,
		int	coeffs_len )

initialize structure for 32 bit FIR filter

Function initialize structure for 32 bit floating point FIR filter The implementation use ANSI C and could be compiled and run on any platform

Parameters

fir	pointer to fir filter structure, that must be preallocated
coeffs	array with FIR filter coefficients. Must be length N
delay	array for FIR filter delay line. Must have a length = coeffs_len + 4
coeffs_len	FIR filter length. Length of coeffs array. For esp32s3 length should be divided by 4 and aligned to 16.

Returns

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

Definition at line 19 of file dsps_fir_init_f32.c.

{
    // Allocate delay line in case if it's NULL
    if (delay == NULL) {
#ifdef CONFIG_IDF_TARGET_ESP32S3
        delay = (float *)memalign(16, (coeffs_len + 4) * sizeof(float));
#else
        delay = (float *)malloc((coeffs_len + 4) * sizeof(float));
#endif // CONFIG_IDF_TARGET_ESP32S3
        fir->use_delay = 1;
    } else {
        fir->use_delay = 0;
    }
    for (int i = 0; i < (coeffs_len + 4); i++) {
        delay[i] = 0;
    }
    fir->coeffs = coeffs;
    fir->delay = delay;
    fir->N = coeffs_len;
    fir->pos = 0;
 
#ifdef CONFIG_IDF_TARGET_ESP32S3
    if (fir->N % 4 != 0) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
    // The coeffs array should be aligned to 16
    if (((uint32_t)coeffs) & 0x0f) {
        return ESP_ERR_DSP_ARRAY_NOT_ALIGNED;
    }
    // The delay array should be aligned to 16
    if (((uint32_t)delay) & 0x0f) {
        return ESP_ERR_DSP_ARRAY_NOT_ALIGNED;
    }
#endif // CONFIG_IDF_TARGET_ESP32S3
 
    for (int i = 0 ; i < coeffs_len; i++) {
        fir->delay[i] = 0;
    }
    return ESP_OK;
}

References coeffs, fir_f32_s::coeffs, delay, fir_f32_s::delay, ESP_ERR_DSP_ARRAY_NOT_ALIGNED, ESP_ERR_DSP_INVALID_LENGTH, ESP_OK, memalign, fir_f32_s::N, fir_f32_s::pos, and fir_f32_s::use_delay.

Referenced by test_fir().

Here is the caller graph for this function:

dsps_fird_f32_ae32()

int dsps_fird_f32_ae32	(	fir_f32_t *	fir,
		const float *	input,
		float *	output,
		int	len )

dsps_fird_f32_aes3()

int dsps_fird_f32_aes3	(	fir_f32_t *	fir,
		const float *	input,
		float *	output,
		int	len )

dsps_fird_f32_ansi()

int dsps_fird_f32_ansi	(	fir_f32_t *	fir,
		const float *	input,
		float *	output,
		int	len )

32 bit floating point Decimation FIR filter

Function implements FIR filter with decimation The extension (_ansi) uses ANSI C and could be compiled and run on any platform. The extension (_ae32) is optimized for ESP32 chip.

Parameters

fir	pointer to fir filter structure, that must be initialized before
input	input array
output	array with the result of FIR filter
len	length of result array

Returns

: function returns the number of samples stored in the output array depends on the previous state value could be [0..len/decimation]

Definition at line 17 of file dsps_fird_f32_ansi.c.

{
    int result = 0;
    for (int i = 0; i < len ; i++) {
        for (int k = 0 ; k < fir->decim ; k++) {
            fir->delay[fir->pos++] = *input++;
            if (fir->pos >= fir->N) {
                fir->pos = 0;
            }
        }
        float acc = 0;
        int coeff_pos = 0;
        for (int n = fir->pos; n < fir->N ; n++) {
            acc += fir->coeffs[coeff_pos++] * fir->delay[n];
        }
        for (int n = 0; n < fir->pos ; n++) {
            acc += fir->coeffs[coeff_pos++] * fir->delay[n];
        }
        output[result++] = acc;
    }
    return result;
}

References fir_f32_s::coeffs, fir_f32_s::decim, fir_f32_s::delay, k, fir_f32_s::N, N, n, and fir_f32_s::pos.

dsps_fird_f32_arp4()

int dsps_fird_f32_arp4	(	fir_f32_t *	fir,
		const float *	input,
		float *	output,
		int	len )

dsps_fird_init_f32()

esp_err_t dsps_fird_init_f32	(	fir_f32_t *	fir,
		float *	coeffs,
		float *	delay,
		int	N,
		int	decim )

initialize structure for 32 bit Decimation FIR filter Function initialize structure for 32 bit floating point FIR filter with decimation The implementation use ANSI C and could be compiled and run on any platform

Parameters

fir	pointer to fir filter structure, that must be preallocated
coeffs	array with FIR filter coefficients. Must be length N
delay	array for FIR filter delay line. Must be length N
N	FIR filter length. Length of coeffs and delay arrays.
decim	decimation factor.

Returns

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

Definition at line 18 of file dsps_fird_init_f32.c.

{
    fir->coeffs = coeffs;
    fir->delay = delay;
    fir->N = N;
    fir->pos = 0;
    fir->decim = decim;
 
#ifdef CONFIG_IDF_TARGET_ESP32S3
    // The amount of coefficients should be divided to 4,
    // if not, add zero coefficients to round length to 0
    if (fir->N % 4 != 0) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
    // The coeffs array should be aligned to 16
    if (((uint32_t)coeffs) & 0x0f) {
        return ESP_ERR_DSP_ARRAY_NOT_ALIGNED;
    }
    // The delay array should be aligned to 16
    if (((uint32_t)delay) & 0x0f) {
        return ESP_ERR_DSP_ARRAY_NOT_ALIGNED;
    }
#endif // CONFIG_IDF_TARGET_ESP32S3
 
    for (int i = 0 ; i < N; i++) {
        fir->delay[i] = 0;
    }
    return ESP_OK;
}

References coeffs, fir_f32_s::coeffs, fir_f32_s::decim, delay, fir_f32_s::delay, ESP_ERR_DSP_ARRAY_NOT_ALIGNED, ESP_ERR_DSP_INVALID_LENGTH, ESP_OK, fir_f32_s::N, N, and fir_f32_s::pos.

dsps_fird_init_s16()

esp_err_t dsps_fird_init_s16	(	fir_s16_t *	fir,
		int16_t *	coeffs,
		int16_t *	delay,
		int16_t	coeffs_len,
		int16_t	decim,
		int16_t	start_pos,
		int16_t	shift )

initialize structure for 16 bit Decimation FIR filter Function initialize structure for 16 bit signed fixed point FIR filter with decimation The implementation use ANSI C and could be compiled and run on any platform

Parameters

fir	pointer to fir filter structure, that must be preallocated
coeffs	array with FIR filter coefficients. Must be length N
delay	array for FIR filter delay line. Must be length N
coeffs_len	FIR filter length. Length of coeffs and delay arrays.
decim	decimation factor.
start_pos	initial value of decimation counter. Must be [0..d)
shift	shift position of the result

Returns

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

Definition at line 14 of file dsps_fird_init_s16.c.

{
    fir->coeffs = coeffs;
    fir->delay = delay;
    fir->coeffs_len = coeffs_len;
    fir->pos = 0;
    fir->decim = decim;
    fir->d_pos = start_pos;
    fir->shift = shift;
    fir->rounding_val = (int16_t)(ROUNDING_VALUE);
    fir->free_status = 0;
 
    if (fir->coeffs_len < 2) {                                          // number of coeffcients must be higer than 1
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
 
    if ((fir->shift > 40) || (fir->shift < -40)) {                      // shift amount must be within a range from -40 to 40
        return ESP_ERR_DSP_PARAM_OUTOFRANGE;
    }
 
    if (fir->d_pos >= fir->decim) {                                     // start position must be lower than decimation
        return ESP_ERR_DSP_PARAM_OUTOFRANGE;
    }
 
#if CONFIG_DSP_OPTIMIZED
 
    // Rounding value buffer primary for a purpose of ee.ld.accx.ip, but used for both the esp32 and esp32s3
    // dsps_fird_s16_aexx_free() must be called to free the memory after the FIR function is finished
    int32_t *aexx_rounding_buff = (int32_t *)memalign(16, 2 * sizeof(int32_t));
 
    long long rounding = (long long)(fir->rounding_val);
 
    if (fir->shift >= 0) {
        rounding = (rounding >> fir->shift);
    } else {
        rounding = (rounding << (-fir->shift));
    }
#if dsps_fird_s16_arp4_enabled
    fir->pos = start_pos;
 
    int16_t *new_delay_buff = (int16_t *)memalign(16, (coeffs_len + 8 * 2) * sizeof(int16_t));
    for (int i = 0 ; i < (coeffs_len + 8 * 2) ; i++) {
        new_delay_buff[i] = 0;
    }
    fir->delay = &new_delay_buff[8];
    fir->free_status |= 0x0001;
 
#endif // dsps_fird_s16_arp4_enabled
 
 
    aexx_rounding_buff[0] = (int32_t)(rounding);                        // 32 lower bits (acclo) type reassignment to 32-bit
    aexx_rounding_buff[1] = (int32_t)((rounding >> 32) & 0xFF);         // 8 higher bits (acchi) shift by 32 and apply the mask
    fir->rounding_buff = aexx_rounding_buff;
    fir->free_status |= 0x0004;
 
#if dsps_fird_s16_aes3_enabled
 
    if (fir->delay == NULL) {                                   // New delay buffer is allocated if the current delay line is NULL
        int16_t *new_delay_buff = (int16_t *)memalign(16, coeffs_len * sizeof(int16_t));
        fir->delay = new_delay_buff;
        fir->free_status |= 0x0001;
    } else {
        if ((int)fir->delay & 0xf) {                            // Delay line array must be aligned
            return ESP_ERR_DSP_ARRAY_NOT_ALIGNED;
        }
    }
 
    if ((int)fir->coeffs & 0xf) {                               // Coefficients array must be aligned
        return ESP_ERR_DSP_ARRAY_NOT_ALIGNED;
    }
 
    // If the number of coefficients is not divisible by 8, a new delay line a new coefficients arrays are allocated
    // the newly allocated arrays are divisible by 8. Coefficients are copied from the original fir structure to
    // the new coeffs array and the remaining space is filled with zeroes
    // dsps_fird_s16_free_coeffs_delay must be called to free the memory after the FIR function is finished
    if (fir->coeffs_len % 8) {                                           // Number of coefficients must be devisible by 8
        int16_t zero_coeffs = (8 - (fir->coeffs_len % 8));
        int16_t new_coeffs_len = fir->coeffs_len + zero_coeffs;
        int16_t *aes3_delay_buff = (int16_t *)memalign(16, new_coeffs_len * sizeof(int16_t));
        int16_t *aes3_coeffs_buff = (int16_t *)memalign(16, new_coeffs_len * sizeof(int16_t));
 
        for (int i = 0; i < fir->coeffs_len; i++) {                      // copy fir->coeffs to aes3_coeffs_buff
            aes3_coeffs_buff[i] = fir->coeffs[i];
        }
 
        for (int i = fir->coeffs_len; i < new_coeffs_len; i++) {                  // add zeroes to the end
            aes3_coeffs_buff[i] = 0;
        }
 
        fir->delay = aes3_delay_buff;
        fir->coeffs = aes3_coeffs_buff;
        fir->coeffs_len = new_coeffs_len;
        fir->free_status |= 0x0002;
    }
 
#endif      // dsps_fird_s16_aes3_enabled
#endif      // CONFIG_DSP_OPTIMIZED
 
    for (int i = 0; i < fir->coeffs_len; i++) { // Initialize the delay line to zero
        fir->delay[i] = 0;
    }
 
    return ESP_OK;
}

References coeffs, fir_s16_s::coeffs, fir_s16_s::coeffs_len, fir_s16_s::d_pos, fir_s16_s::decim, delay, fir_s16_s::delay, ESP_ERR_DSP_ARRAY_NOT_ALIGNED, ESP_ERR_DSP_INVALID_LENGTH, ESP_ERR_DSP_PARAM_OUTOFRANGE, ESP_OK, fir_s16_s::free_status, memalign, fir_s16_s::pos, fir_s16_s::rounding_buff, fir_s16_s::rounding_val, ROUNDING_VALUE, and fir_s16_s::shift.

dsps_fird_s16_ae32()

int32_t dsps_fird_s16_ae32	(	fir_s16_t *	fir,
		const int16_t *	input,
		int16_t *	output,
		int32_t	len )

dsps_fird_s16_aes3()

int32_t dsps_fird_s16_aes3	(	fir_s16_t *	fir,
		const int16_t *	input,
		int16_t *	output,
		int32_t	len )

dsps_fird_s16_aexx_free()

esp_err_t dsps_fird_s16_aexx_free

(

fir_s16_t *

fir

)

support arrays freeing function

Function frees all the arrays, which were created during the initialization of the fir_s16_t structure

1. frees allocated memory for rounding buffer, for the purposes of esp32s3 ee.ld.accx.ip assembly instruction
2. frees allocated memory in case the delay line is NULL
3. frees allocated memory in case the length of the filter (and the delay line) is not divisible by 8 and new delay line and filter coefficients arrays are created for the purpose of the esp32s3 assembly

Parameters

fir	pointer to fir filter structure, that must be initialized before

Returns

• ESP_OK on success

Definition at line 119 of file dsps_fird_init_s16.c.

{
 
    if (fir->free_status == 0) {
        return ESP_OK;
    }
 
    if (fir->free_status & 0x0003) {
 
        if (fir->free_status & 0x0002) {
            free(fir->coeffs);
        }
#if dsps_fird_s16_arp4_enabled
        fir->delay = &fir->delay[-8];
#endif
        free(fir->delay);
    }
 
    if (fir->free_status & 0x0004) {
        free(fir->rounding_buff);
    }
    fir->free_status = 0;
 
    return ESP_OK;
}

References fir_s16_s::coeffs, fir_s16_s::delay, ESP_OK, fir_s16_s::free_status, and fir_s16_s::rounding_buff.

Referenced by dsps_resampler_mr_free().

Here is the caller graph for this function:

dsps_fird_s16_ansi()

int32_t dsps_fird_s16_ansi	(	fir_s16_t *	fir,
		const int16_t *	input,
		int16_t *	output,
		int32_t	len )

16 bit signed fixed point Decimation FIR filter

Function implements FIR filter with decimation The extension (_ansi) uses ANSI C and could be compiled and run on any platform. The extension (_ae32) is optimized for ESP32 chip.

Parameters

fir	pointer to fir filter structure, that must be initialized before
input	input array
output	array with the result of the FIR filter
len	length of the result array

Returns

: function returns the number of samples stored in the output array depends on the previous state value could be [0..len/decimation]

Definition at line 9 of file dsps_fird_s16_ansi.c.

{
    int32_t result = 0;
    int32_t input_pos = 0;
    long long rounding = 0;
    const int32_t final_shift = fir->shift - 15;
 
    rounding = (long long)(fir->rounding_val);
 
    if (fir->shift >= 0) {
        rounding = (rounding >> fir->shift) & 0xFFFFFFFFFF;         // 40-bit mask
    } else {
        rounding = (rounding << (-fir->shift)) & 0xFFFFFFFFFF;      // 40-bit mask
    }
 
    // len is already a length of the *output array, calculated as (length of the input array / decimation)
    for (int i = 0; i < len; i++) {
 
        for (int j = 0; j < fir->decim - fir->d_pos; j++) {
 
            if (fir->pos >= fir->coeffs_len) {
                fir->pos = 0;
            }
            fir->delay[fir->pos++] = input[input_pos++];
        }
        fir->d_pos = 0;
 
        long long acc = rounding;
        int16_t coeff_pos = fir->coeffs_len - 1;
 
        for (int n = fir->pos; n < fir->coeffs_len ; n++) {
            acc += (int32_t)fir->coeffs[coeff_pos--] * (int32_t)fir->delay[n];
        }
        for (int n = 0; n < fir->pos ; n++) {
            acc += (int32_t)fir->coeffs[coeff_pos--] * (int32_t)fir->delay[n];
        }
 
        if (final_shift > 0) {
            output[result++] = (int16_t)(acc << final_shift);
        } else {
            output[result++] = (int16_t)(acc >> (-final_shift));
        }
 
    }
    return result;
}

References fir_s16_s::coeffs, fir_s16_s::coeffs_len, fir_s16_s::d_pos, fir_s16_s::decim, fir_s16_s::delay, n, fir_s16_s::pos, fir_s16_s::rounding_val, and fir_s16_s::shift.

dsps_fird_s16_arp4()

int32_t dsps_fird_s16_arp4	(	fir_s16_t *	fir,
		const int16_t *	input,
		int16_t *	output,
		int32_t	len )

References coeffs, and delay.

dsps_firmr_f32_ansi()

int dsps_firmr_f32_ansi	(	fir_f32_t *	fir,
		const float *	input,
		float *	output,
		int	input_len )

32 bit floating point multi-rate FIR filter

Function implements FIR filter with decimation The extension (_ansi) uses ANSI C and could be compiled and run on any platform. The extension (_ae32) is optimized for ESP32 chip.

Parameters

fir	pointer to fir filter structure, that must be initialized before
input	input array
output	array with the result of the FIR filter
input_len	length of the input array

Returns

• amount of samples stored in the output array
• depends on the previous state value
• could be [0..len*intepr/decimation]

Definition at line 14 of file dsps_firmr_f32_ansi.c.

{
    int m = fir->start_pos;
    int result = 0;
 
    for (int i = 0; i < input_len; i++) {
        fir->delay[fir->pos] = input[i];
 
        for (m = fir->start_pos; m < fir->interp; m += fir->decim) {
            float fir_sum = 0;
            int coeff_pos = 0;
            for (int n = fir->pos; n < fir->delay_size; n++) {
                fir_sum += fir->delay[n] * fir->coeffs[coeff_pos++ * fir->interp + m];
            }
            for (int n = 0; n < fir->pos; n++) {
                fir_sum += fir->delay[n] * fir->coeffs[coeff_pos++ * fir->interp + m];
            }
            output[result++] = fir_sum;
        }
        fir->start_pos = m - fir->interp;
 
        fir->pos--;
        if (fir->pos < 0) {
            fir->pos = fir->delay_size - 1;
        }
    }
    return result;
}

References fir_f32_s::coeffs, fir_f32_s::decim, fir_f32_s::delay, fir_f32_s::delay_size, fir_f32_s::interp, m, n, fir_f32_s::pos, and fir_f32_s::start_pos.

dsps_firmr_init_f32()

esp_err_t dsps_firmr_init_f32	(	fir_f32_t *	fir,
		float *	coeffs,
		float *	delay,
		int	length,
		int	interp,
		int	decim,
		int	start_pos )

initialize structure for multi-rate FIR filter Function initialize structure for 32 bit floating point multi-rate FIR filter The implementation use ANSI C and could be compiled and run on any platform

Parameters

fir	pointer to fir filter structure, that must be preallocated
coeffs	array with FIR filter coefficients. Must be length N
delay	array for FIR filter delay line. Must be length N
length	FIR filter length. Length of coeffs and delay arrays.
interp	interpolation factor.
decim	decimation factor.
start_pos	initial value of decimation counter. Must be [0..decim)

Returns

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

Definition at line 12 of file dsps_firmr_init_f32.c.

{
    fir->coeffs = coeffs;
    fir->delay = delay;
    fir->N = length;
    fir->pos = 0;
    fir->decim = decim;
    fir->use_delay = 0;
    fir->interp = interp;
    fir->interp_pos = 0;
    fir->start_pos = start_pos;
    fir->delay_size = length / interp;
 
    if (delay == NULL) {
#ifdef CONFIG_IDF_TARGET_ESP32S3
        fir->delay = (float *)memalign(16, (fir->delay_size + 4) * sizeof(float));
#else
        fir->delay = (float *)malloc((fir->delay_size + 4) * sizeof(float));
#endif // CONFIG_IDF_TARGET_ESP32S3
        fir->use_delay = 1;
    } else {
        fir->use_delay = 0;
    }
 
    if (decim == 0) {
        return ESP_ERR_DSP_INVALID_PARAM;
    }
    if (interp == 0) {
        return ESP_ERR_DSP_INVALID_PARAM;
    }
    if (length % interp != 0) {
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
    if (start_pos < 0 || start_pos >= decim) {
        return ESP_ERR_DSP_INVALID_PARAM;
    }
 
#ifdef CONFIG_IDF_TARGET_ESP32S3
    // The delay array should be aligned to 16
    if (((uint32_t)delay) & 0x0f) {
        return ESP_ERR_DSP_ARRAY_NOT_ALIGNED;
    }
#endif // CONFIG_IDF_TARGET_ESP32S3
 
    for (int i = 0 ; i < fir->delay_size; i++) {
        fir->delay[i] = 0;
    }
    return ESP_OK;
}

References coeffs, fir_f32_s::coeffs, fir_f32_s::decim, delay, fir_f32_s::delay, fir_f32_s::delay_size, ESP_ERR_DSP_ARRAY_NOT_ALIGNED, ESP_ERR_DSP_INVALID_LENGTH, ESP_ERR_DSP_INVALID_PARAM, ESP_OK, fir_f32_s::interp, fir_f32_s::interp_pos, memalign, fir_f32_s::N, fir_f32_s::pos, fir_f32_s::start_pos, and fir_f32_s::use_delay.

Referenced by dsps_resampler_mr_init().

Here is the caller graph for this function:

dsps_firmr_init_s16()

esp_err_t dsps_firmr_init_s16	(	fir_s16_t *	fir,
		int16_t *	coeffs,
		int16_t *	delay,
		int16_t	length,
		int16_t	interp,
		int16_t	decim,
		int16_t	start_pos,
		int16_t	shift )

initialize structure for multi-rate FIR filter Function initialize structure for 16 bit signed fixed point multi-rate FIR filter The implementation use ANSI C and could be compiled and run on any platform

Parameters

fir	pointer to fir filter structure, that must be preallocated
coeffs	array with FIR filter coefficients. Must be length N
delay	array for FIR filter delay line. Must be length N
length	FIR filter length. Length of coeffs and delay arrays.
interp	interpolation factor.
decim	decimation factor.
start_pos	initial value of decimation counter. Must be [0..decim)
shift	shift of accumulator value to store in the output array.

Returns

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

Definition at line 15 of file dsps_firmr_init_s16.c.

{
    fir->coeffs = coeffs;
    fir->delay = delay;
 
 
    fir->coeffs_len = coeffs_len;
    fir->pos = 0;
    fir->decim = decim;
    fir->d_pos = start_pos;
    fir->shift = shift;
    fir->rounding_val = (int16_t)(ROUNDING_VALUE);
    fir->free_status = 0;
 
    if (delay == NULL) {
#ifdef CONFIG_IDF_TARGET_ESP32S3
        fir->delay = (int16_t *)memalign(16, (fir->delay_size + 4) * sizeof(int16_t));
#else
        fir->delay = (int16_t *)malloc((fir->delay_size + 4) * sizeof(int16_t));
#endif // CONFIG_IDF_TARGET_ESP32S3
        fir->free_status = 1;
    } else {
        fir->free_status = 0;
    }
 
 
    fir->interp = interp;
    fir->interp_pos = 0;
    fir->start_pos = start_pos;
    fir->delay_size = coeffs_len / interp;
 
 
    if (fir->coeffs_len < 2) {                                          // number of coeffcients must be higer than 1
        return ESP_ERR_DSP_INVALID_LENGTH;
    }
 
    if ((fir->shift > 40) || (fir->shift < -40)) {                      // shift amount must be within a range from -40 to 40
        return ESP_ERR_DSP_PARAM_OUTOFRANGE;
    }
 
    if (fir->d_pos >= fir->decim) {                                     // start position must be lower than decimation
        return ESP_ERR_DSP_PARAM_OUTOFRANGE;
    }
 
    for (int i = 0; i < fir->delay_size; i++) {                                  // Initialize the delay line to zero
        fir->delay[i] = 0;
    }
 
    return ESP_OK;
}

References coeffs, fir_s16_s::coeffs, fir_s16_s::coeffs_len, fir_s16_s::d_pos, fir_s16_s::decim, delay, fir_s16_s::delay, fir_s16_s::delay_size, ESP_ERR_DSP_INVALID_LENGTH, ESP_ERR_DSP_PARAM_OUTOFRANGE, ESP_OK, fir_s16_s::free_status, fir_s16_s::interp, fir_s16_s::interp_pos, memalign, fir_s16_s::pos, fir_s16_s::rounding_val, ROUNDING_VALUE, fir_s16_s::shift, and fir_s16_s::start_pos.

Referenced by dsps_resampler_mr_init().

Here is the caller graph for this function:

dsps_firmr_s16_ansi()

int32_t dsps_firmr_s16_ansi	(	fir_s16_t *	fir,
		const int16_t *	input,
		int16_t *	output,
		int32_t	input_len )

16 bit signed fixed point multi-rate FIR filter

Function implements FIR filter with decimation The extension (_ansi) uses ANSI C and could be compiled and run on any platform. The extension (_ae32) is optimized for ESP32 chip.

Parameters

fir	pointer to fir filter structure, that must be initialized before
input	input array
output	array with the result of the FIR filter
input_len	length of the intput array

Returns

: function returns the number of samples stored in the output array depends on the previous state value could be [0..len*intepr/decimation]

Definition at line 11 of file dsps_firmr_s16_ansi.c.

{
    int32_t result = 0;
    long long rounding = 0;
    const int32_t final_shift = fir->shift - 15;
    rounding = (long long)(fir->rounding_val);
 
    if (fir->shift >= 0) {
        rounding = (rounding >> fir->shift) & 0xFFFFFFFFFF;         // 40-bit mask
    } else {
        rounding = (rounding << (-fir->shift)) & 0xFFFFFFFFFF;      // 40-bit mask
    }
 
    int32_t m = fir->start_pos;
 
    for (int i = 0; i < input_len; i++) {
        fir->delay[fir->pos] = input[i];
 
        for (m = fir->start_pos; m < fir->interp; m += fir->decim) {
            long long acc = rounding;
            int coeff_pos = 0;
            for (int n = fir->pos; n < fir->delay_size; n++) {
                acc += (int32_t)fir->delay[n] * (int32_t)fir->coeffs[coeff_pos++ * fir->interp + m];
            }
            for (int n = 0; n < fir->pos; n++) {
                acc += (int32_t)fir->delay[n] * (int32_t)fir->coeffs[coeff_pos++ * fir->interp + m];
            }
 
            if (final_shift > 0) {
                output[result++] = (int16_t)(acc << final_shift);
            } else {
                output[result++] = (int16_t)(acc >> (-final_shift));
            }
        }
        fir->start_pos = m - fir->interp;
 
        fir->pos--;
        if (fir->pos < 0) {
            fir->pos = fir->delay_size - 1;
        }
    }
 
    return result;
}

References fir_s16_s::coeffs, fir_s16_s::decim, fir_s16_s::delay, fir_s16_s::delay_size, fir_s16_s::interp, m, n, fir_s16_s::pos, fir_s16_s::rounding_val, fir_s16_s::shift, and fir_s16_s::start_pos.