ESP-DSP Library

https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/
Admin
The ESP-DSP Library is a C/C++ library providing high-performance functions and classes for DSP...
Tokens:15,841
Snippets:127
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### dsps_cplx_gen_init

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Initializes a structure for a complex signal generator.

```APIDOC
## esp_err_t dsps_cplx_gen_init(cplx_sig_t *cplx_gen, out_d_type d_type, void *lut, int32_t lut_len, float freq, float initial_phase)

### Description
Initializes a structure for either 16-bit fixed point or 32-bit floating point complex generator using a LUT table.

### Parameters
- **cplx_gen** (cplx_sig_t *) - Pointer to the floating point generator structure
- **d_type** (out_d_type) - Output data type
- **lut** (void *) - Pointer to a user-defined LUT
- **lut_len** (int32_t) - Length of the LUT
- **freq** (float) - Frequency of the output signal in range [-1, 1]
- **initial_phase** (float) - Initial phase of the complex signal in range [-1, 1]

### Returns
- **ESP_OK** on success
- Error codes from DSP library
```

--------------------------------

### dsps_wind_nuttall_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates a Nuttall window.

```APIDOC
## void dsps_wind_nuttall_f32(float *window, int len)

### Description
Generates a Nuttall window and stores it in the provided buffer.

### Parameters
- **window** (float*) - Buffer to store window array.
- **len** (int) - Length of the window array.
```

--------------------------------

### dsps_fird_init_s16

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Initializes a 16-bit signed fixed-point FIR filter structure with decimation.

```APIDOC
## 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)

### Description
Initializes the structure for a 16-bit signed fixed-point FIR filter with decimation.

### Parameters
- **fir** (fir_s16_t*) - Required - Pointer to the preallocated FIR filter structure.
- **coeffs** (int16_t*) - Required - Array with FIR filter coefficients of length N.
- **delay** (int16_t*) - Required - Array for FIR filter delay line of length N.
- **coeffs_len** (int16_t) - Required - FIR filter length.
- **decim** (int16_t) - Required - Decimation factor.
- **start_pos** (int16_t) - Required - Initial value of decimation counter [0..d).
- **shift** (int16_t) - Required - Shift position of the result.

### Return
- **ESP_OK** - Success
- **Error Code** - One of the error codes from the DSP library
```

--------------------------------

### ekf_imu13states::Init

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Initializes the EKF. This method must be called before the first use of the filter.

```APIDOC
## void Init()

### Description
Initialization of EKF. The method should be called before the first use of the filter.
```

--------------------------------

### dsps_firmr_init_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Initializes the structure for a 32-bit floating point multi-rate FIR filter.

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

### Description
Initializes the structure for a 32-bit floating point multi-rate FIR filter using ANSI C.

### Parameters
- **fir** (fir_f32_t*) - Required - Pointer to preallocated FIR filter structure.
- **coeffs** (float*) - Required - Array with FIR filter coefficients (length N).
- **delay** (float*) - Required - Array for FIR filter delay line (length N).
- **length** (int) - Required - FIR filter length.
- **interp** (int) - Required - Interpolation factor.
- **decim** (int) - Required - Decimation factor.
- **start_pos** (int) - Required - Initial value of decimation counter [0..decim).

### Return
- ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_fft4r_init_fc32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Initializes the coefficients table for Complex FFT Radix-4 operations.

```APIDOC
## esp_err_t dsps_fft4r_init_fc32(float *fft_table_buff, int max_fft_size)

### Description
Initializes the coefficients table required for Complex FFT Radix-4. If fft_table_buff is NULL, the buffer is allocated internally.

### Parameters
- **fft_table_buff** (float*) - Required - Pointer to floating point buffer for sin/cos table.
- **max_fft_size** (int) - Required - Maximum FFT size.

### Response
- **ESP_OK** - Success
- **ESP_ERR_DSP_PARAM_OUTOFRANGE** - table_size > CONFIG_DSP_MAX_FFT_SIZE
- **ESP_ERR_DSP_REINITIALIZED** - Buffer already allocated
```

--------------------------------

### dsps_wind_flat_top_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates a Flat-Top window.

```APIDOC
## void dsps_wind_flat_top_f32(float *window, int len)

### Description
Generates a Flat-Top window and stores it in the provided buffer.

### Parameters
- **window** (float*) - Buffer to store window array.
- **len** (int) - Length of the window array.
```

--------------------------------

### dsps_wind_blackman_nuttall_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates a Blackman-Nuttall window.

```APIDOC
## void dsps_wind_blackman_nuttall_f32(float *window, int len)

### Description
Generates a Blackman-Nuttall window and stores it in the provided buffer.

### Parameters
- **window** (float*) - Buffer to store window array.
- **len** (int) - Length of the window array.
```

--------------------------------

### dsps_fird_init_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Initializes a 32-bit floating-point FIR filter structure with decimation.

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

### Description
Initializes the structure for a 32-bit floating-point FIR filter with decimation.

### Parameters
- **fir** (fir_f32_t*) - Required - Pointer to the preallocated FIR filter structure.
- **coeffs** (float*) - Required - Array with FIR filter coefficients of length N.
- **delay** (float*) - Required - Array for FIR filter delay line of length N.
- **N** (int) - Required - FIR filter length.
- **decim** (int) - Required - Decimation factor.

### Return
- **ESP_OK** - Success
- **Error Code** - One of the error codes from the DSP library
```

--------------------------------

### dsps_fir_init_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Initializes a 32-bit floating-point FIR filter structure.

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

### Description
Initializes the structure for a 32-bit floating-point FIR filter using ANSI C.

### Parameters
- **fir** (fir_f32_t*) - Required - Pointer to the preallocated FIR filter structure.
- **coeffs** (float*) - Required - Array with FIR filter coefficients of length N.
- **delay** (float*) - Required - Array for FIR filter delay line of length = coeffs_len + 4.
- **coeffs_len** (int) - Required - FIR filter length.

### Return
- **ESP_OK** - Success
- **Error Code** - One of the error codes from the DSP library
```

--------------------------------

### ekf_imu13states::UpdateRefMeasurementMagn

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Updates the full system state using accelerometer and magnetometer reference measurements, typically used during the calibration phase.

```APIDOC
## void UpdateRefMeasurementMagn(float *accel_data, float *magn_data, float R[6])

### Description
Update full system state by reference measurements accelerometer and magnetometer. This method should be used at calibration phase.

### Parameters
- **accel_data** (float*) - Required - Accelerometer measurement vector XYZ in g.
- **magn_data** (float*) - Required - Magnetometer measurement vector XYZ.
- **R** (float[6]) - Required - Measurement noise covariance values for diagonal covariance matrix.
```

--------------------------------

### dsps_fft2r_init_fc32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Initializes the coefficients table for Complex FFT. This function can allocate a buffer internally if the provided buffer is NULL.

```APIDOC
## dsps_fft2r_init_fc32

### Description
Initializes the coefficients table for Complex FFT. The implementation uses ANSI C and is platform-independent.

### Parameters
- **fft_table_buff** (float*) - In/Out - Pointer to floating point buffer for sin/cos table. If NULL, buffer is allocated internally.
- **table_size** (int) - In - Size of the buffer in float words.

### Returns
- **esp_err_t** - ESP_OK on success, ESP_ERR_DSP_PARAM_OUTOFRANGE if table_size exceeds limits, or ESP_ERR_DSP_REINITIALIZED if buffer already allocated.
```

--------------------------------

### dsps_wind_blackman_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates a Blackman window.

```APIDOC
## void dsps_wind_blackman_f32(float *window, int len)

### Description
Generates a Blackman window for alpha = 0.16 and stores it in the provided buffer.

### Parameters
- **window** (float*) - Buffer to store window array.
- **len** (int) - Length of the window array.
```

--------------------------------

### dsps_wind_hann_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates a Hann window.

```APIDOC
## void dsps_wind_hann_f32(float *window, int len)

### Description
Generates a Hann window and stores it in the provided buffer.

### Parameters
- **window** (float*) - Buffer to store window array.
- **len** (int) - Length of the window array.
```

--------------------------------

### ekf_imu13states::UpdateRefMeasurement

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Updates the system state using accelerometer and magnetometer reference measurements. This is the main method to be used after calibration.

```APIDOC
## void UpdateRefMeasurement(float *accel_data, float *magn_data, float R[6])

### Description
Update part of system state by reference measurements accelerometer and magnetometer. Only attitude and gyro bias will be updated.

### Parameters
- **accel_data** (float*) - Required - Accelerometer measurement vector XYZ in g.
- **magn_data** (float*) - Required - Magnetometer measurement vector XYZ.
- **R** (float[6]) - Required - Measurement noise covariance values for diagonal covariance matrix.
```

--------------------------------

### dsps_wind_blackman_harris_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates a Blackman-Harris window.

```APIDOC
## void dsps_wind_blackman_harris_f32(float *window, int len)

### Description
Generates a Blackman-Harris window and stores it in the provided buffer.

### Parameters
- **window** (float*) - Buffer to store window array.
- **len** (int) - Length of the window array.
```

--------------------------------

### dsps_view

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Visualizes signal data as a plot in the console.

```APIDOC
## void dsps_view(const float *data, int32_t len, int width, int height, float min, float max, char view_char)

### Description
Displays input samples as a plot in the console for debugging purposes.

### Parameters
- **data** (const float*) - Required - Array with input samples.
- **len** (int32_t) - Required - Length of the input array.
- **width** (int) - Required - Plot width in symbols.
- **height** (int) - Required - Plot height in lines.
- **min** (float) - Required - Minimum value for Axis Y.
- **max** (float) - Required - Maximum value for Axis Y.
- **view_char** (char) - Required - Character to draw the plot values.
```

--------------------------------

### tie_log

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Logging function for ESP32-S3 TIE core registers.

```APIDOC
## esp_err_t tie_log(int n_regs, ...)

### Description
Logging for ESP32-S3 TIE core. Registers covered are q0 to q7, ACCX, and SAR_BYTE.

### Parameters
- **n_regs** (int) - Number of registers to be logged at once.
- **...** (variadic) - Register codes (0, 1, 2, 3, 4, 5, 6, 7, 'a', 's').

### Returns
- **esp_err_t** - ESP_OK on success.
```

--------------------------------

### Mat::ones

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Creates a matrix filled with ones.

```APIDOC
## static Mat ones(int size)
## static Mat ones(int rows, int cols)

### Description
Create a matrix and fill all elements with 1.

### Parameters
- **size** (int) - Required - Matrix size (for square matrix)
- **rows** (int) - Required - Matrix rows
- **cols** (int) - Required - Matrix cols

### Return
- **matrix** (Mat) - Matrix [N]x[N] with 1 in all elements
```

--------------------------------

### Development and Test Method

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Method intended for development and testing purposes only.

```cpp
Method for development and tests only.
```

--------------------------------

### dsps_gen_w_r2_fc32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates the coefficients table for the FFT radix 2. This function is typically called during initialization and uses ANSI C for platform-independent execution.

```APIDOC
## dsps_gen_w_r2_fc32

### Description
Generates coefficients table for the FFT radix 2. This function is called inside init and uses ANSI C.

### Parameters
- **w** (float*) - [inout] Memory location to store coefficients.
- **N** (int) - [in] Maximum size of the FFT that will be used.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### void cplx_gen_free(cplx_sig_t *cplx_gen)

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Frees memory allocated for the complex generator.

```APIDOC
## void cplx_gen_free(cplx_sig_t *cplx_gen)

### Description
Frees dynamically allocated memory associated with the complex generator. Should be called when the generator is no longer needed.

### Parameters
- **cplx_gen** (cplx_sig_t*) - Required - Pointer to the complex signal generator structure.
```

--------------------------------

### dspm_mult_3x3x1_f32_ae32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Optimized matrix multiplication for 3x3 and 3x1 floating point matrices: C[1][3] = A[3][3] * B[3][1].

```APIDOC
## esp_err_t dspm_mult_3x3x1_f32_ae32(const float *A, const float *B, float *C)

### Description
Optimized matrix multiplication for 3x3 and 3x1 floating point matrices for ESP32.

### Parameters
- **A** (const float*) - Input matrix A[3][3]
- **B** (const float*) - Input matrix/vector B[3][1]
- **C** (float*) - Result matrix/vector C[3][3]

### Response
- **Return** (esp_err_t) - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_firmr_f32_ansi

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

32-bit floating point multi-rate FIR filter implementation.

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

### Description
Implements a multi-rate FIR filter with decimation using ANSI C.

### Parameters
- **fir** (fir_f32_t*) - Required - Pointer to initialized FIR filter structure.
- **input** (const float*) - Required - Input array.
- **output** (float*) - Required - Array to store the result.
- **input_len** (int) - Required - Length of the input array.

### Return
- Returns the number of samples stored in the output array (range: [0..len*interp/decimation]).
```

--------------------------------

### Mat Class

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

The Mat class provides basic matrix operations on single-precision floating point values, including ROI extraction and data copying.

```APIDOC
## Mat Class

### Description
Provides matrix management and operations. Constructors allow allocation of internal buffers or usage of external buffers.

### Methods
- **Mat(int rows, int cols)**: Constructor to allocate internal buffer.
- **Mat(float *data, int rows, int cols)**: Constructor using external buffer.
- **Mat(float *data, int rows, int cols, int stride)**: Constructor using external buffer with stride.
- **Mat getROI(int startRow, int startCol, int roiRows, int roiCols)**: Create a subset of matrix as ROI.
- **void Copy(const Mat &src, int row_pos, int col_pos)**: Copy matrix data.
- **void CopyHead(const Mat &src)**: Shallow copy of matrix header.
- **void PrintHead(void)**: Print matrix header information to terminal.
```

--------------------------------

### Mat Class Methods

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

The Mat class provides various methods for matrix operations, including element access, arithmetic operators, and linear algebra functions.

```APIDOC
## Mat::Get(const Mat::Rect &rect)

### Description
Creates a copy of a rectangular area of the matrix.

### Parameters
- **rect** (Mat::Rect) - Required - The rectangular area of interest.

### Return
- **Mat** - Result matrix of size row_size x col_size.

## Mat::operator()(int row, int col)

### Description
Accesses matrix elements at the specified row and column.

### Parameters
- **row** (int) - Required - Row position.
- **col** (int) - Required - Column position.

### Return
- **float&** - Reference to the element at M[row][col].

## Mat::swapRows(int row1, int row2)

### Description
Swaps two rows within the matrix.

### Parameters
- **row1** (int) - Required - Position of the first row.
- **row2** (int) - Required - Position of the second row.

## Mat::t()

### Description
Performs matrix transposition, swapping rows and columns.

### Return
- **Mat** - The transposed matrix.

## Mat::inverse()

### Description
Calculates the inverse of the matrix.

### Return
- **Mat** - The inverse matrix.

## Mat::det(int n)

### Description
Calculates the determinant of the matrix.

### Parameters
- **n** (int) - Required - Element number in the first row.

### Return
- **float** - The determinant value.
```

--------------------------------

### dsps_biquad_gen_lowShelf_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates coefficients for a low shelf IIR filter.

```APIDOC
## esp_err_t dsps_biquad_gen_lowShelf_f32(float *coeffs, float f, float gain, float qFactor)

### Description
Generates coefficients for a low pass Shelf 2nd order IIR filter (bi-quad).

### Parameters
- **coeffs** (float*) - Result coefficients.
- **f** (float) - Filter frequency in range of 0..0.5 (normalized to sample frequency).
- **gain** (float) - Gain in stopband in dB.
- **qFactor** (float) - Q factor of the filter.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### Mat::solve

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Solves the matrix equation A*x = b.

```APIDOC
## static Mat solve(Mat A, Mat b)

### Description
Find roots for the matrix equation A*x = b.

### Parameters
- **A** (Mat) - Required - Matrix [N]x[N] with input coefficients
- **b** (Mat) - Required - Vector [N]x[1] with result values

### Return
- **matrix** (Mat) - Matrix [N]x[1] with roots
```

--------------------------------

### dspi_dotprod_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Calculates the dot product of two floating-point images.

```APIDOC
## Function: dspi_dotprod_f32_ansi

### Description
Calculates the dot product for two floating-point images: _out_value += image[i_ …] * src2[i*…]); i= [0..count_x*count_y).

### Parameters
- **in_image** (image2d_t*) - Required - Input image
- **filter** (image2d_t*) - Required - Filter image
- **out_value** (float*) - Required - Output value pointer
- **count_x** (int) - Required - X dimension count
- **count_y** (int) - Required - Y dimension count

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_biquad_gen_highShelf_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates coefficients for a high shelf IIR filter.

```APIDOC
## esp_err_t dsps_biquad_gen_highShelf_f32(float *coeffs, float f, float gain, float qFactor)

### Description
Generates coefficients for a high pass Shelf 2nd order IIR filter (bi-quad).

### Parameters
- **coeffs** (float*) - Result coefficients.
- **f** (float) - Filter frequency in range of 0..0.5 (normalized to sample frequency).
- **gain** (float) - Gain in stopband in dB.
- **qFactor** (float) - Q factor of the filter.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_fft2r_fc32_ansi_

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Performs a complex FFT of radix 2 using ANSI C implementation.

```APIDOC
## dsps_fft2r_fc32_ansi_

### Description
Performs a complex FFT of radix 2. The result is stored in the input array.

### Parameters
- **data** (float*) - In/Out - Complex array containing Re[0], Im[0], ... Re[N-1], Im[N-1].
- **N** (int) - In - Number of complex elements.
- **w** (float*) - In - Pointer to the sin/cos table.

### Returns
- **esp_err_t** - ESP_OK on success.
```

--------------------------------

### dspm_mult_3x3x3_f32_ae32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Optimized matrix multiplication for two square 3x3 floating point matrices: C[3][3] = A[3][3] * B[3][3].

```APIDOC
## esp_err_t dspm_mult_3x3x3_f32_ae32(const float *A, const float *B, float *C)

### Description
Optimized matrix multiplication for two square 3x3 floating point matrices for ESP32.

### Parameters
- **A** (const float*) - Input matrix A[3][3]
- **B** (const float*) - Input matrix B[3][3]
- **C** (float*) - Result matrix C[3][3]

### Response
- **Return** (esp_err_t) - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_fft4r_fc32_ansi_

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Performs a Complex FFT of radix 4 using ANSI C.

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

### Description
Executes a Complex FFT of radix 4. The implementation uses ANSI C and is platform-independent.

### Parameters
- **data** (float*) - Required - Input/output complex array.
- **N** (int) - Required - Number of complex elements.
- **table** (float*) - Required - Pointer to sin/cos table.
- **table_size** (int) - Required - Size of the sin/cos table.
```

--------------------------------

### dsps_fird_f32_ae32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

32-bit floating point Decimation FIR filter optimized for ESP32.

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

### Description
Implements a FIR filter with decimation optimized for the ESP32 chip.

### Parameters
- **fir** (fir_f32_t*) - Required - Pointer to initialized FIR filter structure.
- **input** (const float*) - Required - Input array.
- **output** (float*) - Required - Array to store the result.
- **len** (int) - Required - Length of the result array.

### Return
- Returns the number of samples stored in the output array (range: [0..len/decimation]).
```

--------------------------------

### dsps_biquad_gen_lpf_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates coefficients for a low-pass 2nd order IIR filter (bi-quad).

```APIDOC
## dsps_biquad_gen_lpf_f32

### Description
Generates coefficients for a low-pass 2nd order IIR filter (bi-quad). The implementation uses ANSI C and is platform-independent.

### Parameters
- **coeffs** (float*) - Required - Array to store result coefficients (b0, b1, b2, a1, a2).
- **f** (float) - Required - Filter cut-off frequency in range 0..0.5 (normalized to sample frequency).
- **qFactor** (float) - Required - Q factor of the filter.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_biquad_gen_bpf_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates coefficients for a band-pass 2nd order IIR filter (bi-quad).

```APIDOC
## dsps_biquad_gen_bpf_f32

### Description
Generates coefficients for a band-pass 2nd order IIR filter (bi-quad). The implementation uses ANSI C and is platform-independent.

### Parameters
- **coeffs** (float*) - Required - Array to store result coefficients (b0, b1, b2, a1, a2).
- **f** (float) - Required - Filter center frequency in range 0..0.5 (normalized to sample frequency).
- **qFactor** (float) - Required - Q factor of the filter.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### Mat::eye

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Creates an identity matrix of a specified size.

```APIDOC
## static Mat eye(int size)

### Description
Create a square identity matrix and fill the diagonal with 1.

### Parameters
- **size** (int) - Required - Matrix size

### Return
- **matrix** (Mat) - Matrix [N]x[N] with 1 in diagonal
```

--------------------------------

### dsps_fird_s16_aexx_free

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Frees all arrays and memory allocated during the initialization of the fir_s16_t structure.

```APIDOC
## esp_err_t dsps_fird_s16_aexx_free(fir_s16_t *fir)

### Description
Frees all the arrays created during the initialization of the fir_s16_t structure, including rounding buffers and delay lines.

### Parameters
- **fir** (fir_s16_t*) - Required - Pointer to the FIR filter structure that must be initialized before calling this function.

### Return
- **ESP_OK** - Success
```

--------------------------------

### dsps_fir_f32_free

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Frees the delay line arrays for a 32-bit FIR filter structure.

```APIDOC
## esp_err_t dsps_fir_f32_free(fir_f32_t *fir)

### Description
Frees the delay line arrays if they were allocated by the initialization functions.

### Parameters
- **fir** (fir_f32_t*) - Required - Pointer to the FIR filter structure that must be initialized before calling this function.

### Return
- **ESP_OK** - Success
```

--------------------------------

### dsps_sfdr_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Calculates the Spurious-Free Dynamic Range (SFDR).

```APIDOC
## float dsps_sfdr_f32(const float *input, int32_t len, int8_t use_dc)

### Description
Calculates SFDR by performing an FFT and comparing the maximum spectrum value with all others. Intended for debug and unit tests.

### Parameters
- **input** (const float*) - Required - Input array.
- **len** (int32_t) - Required - Length of the input signal.
- **use_dc** (int8_t) - Required - 0: exclude DC power, 1: include DC power.

### Return
- **float** - SFDR in dB.
```

--------------------------------

### dsps_biquad_gen_peakingEQ_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates coefficients for a peaking EQ IIR filter.

```APIDOC
## esp_err_t dsps_biquad_gen_peakingEQ_f32(float *coeffs, float f, float qFactor)

### Description
Generates coefficients for a peak 2nd order IIR filter (bi-quad).

### Parameters
- **coeffs** (float*) - Result coefficients.
- **f** (float) - Filter frequency in range of 0..0.5 (normalized to sample frequency).
- **qFactor** (float) - Q factor of the filter.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dspi_dotprod_s16_ansi

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Calculates the dot product of two images using ANSI C. This function is platform-independent.

```APIDOC
## esp_err_t dspi_dotprod_s16_ansi(image2d_t *in_image, image2d_t *filter, int16_t *out_value, int count_x, int count_y, int shift)

### Description
Calculates the dot product of two images: out_value += image[i] * src2[i]. The function uses ANSI C for portability.

### Parameters
- **in_image** (image2d_t*) - Input: Descriptor of the image.
- **filter** (image2d_t*) - Input: Descriptor of the filter.
- **out_value** (int16_t*) - Output: Pointer to the output value.
- **count_x** (int) - Input: Amount of samples by X axis.
- **count_y** (int) - Input: Amount of samples by Y axis.
- **shift** (int) - Input: Result shift to right (default 15 for int16_t).

### Return
- **ESP_OK** on success, or an error code from the DSP library.
```

--------------------------------

### dsps_fir_f32_ansi

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Implements a 32-bit floating point FIR filter using ANSI C.

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

### Description
Implements a 32-bit floating point FIR filter. The filter structure must be initialized before calling this function.

### Parameters
- **fir** (fir_f32_t*) - Required - Pointer to the initialized FIR filter structure.
- **input** (const float*) - Required - Input data array.
- **output** (float*) - Required - Array to store the result of the FIR filter.
- **len** (int) - Required - Length of the input and output arrays.

### Return
- **ESP_OK** on success, or an error code from the DSP library.
```

--------------------------------

### dsps_dotprode_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Calculates the dot product of two floating-point vectors with specific step increments.

```APIDOC
## Function: dsps_dotprode_f32_ansi

### Description
Calculates the dot product of two floating-point arrays with steps: *dest += (src1[i*step1] * src2[i*step2]); i= [0..N).

### Parameters
- **src1** (const float*) - Required - Source array 1
- **src2** (const float*) - Required - Source array 2
- **dest** (float*) - Required - Destination pointer
- **len** (int) - Required - Length of input arrays
- **step1** (int) - Required - Step over elements in first array
- **step2** (int) - Required - Step over elements in second array

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### esp_err_t dsps_cplx_gen_ansi(cplx_sig_t *cplx_gen, void *output, int32_t len)

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates a complex signal using ANSI C implementation.

```APIDOC
## esp_err_t dsps_cplx_gen_ansi(cplx_sig_t *cplx_gen, void *output, int32_t len)

### Description
Generates a complex signal in the form of two harmonic signals. This implementation is portable across platforms.

### Parameters
- **cplx_gen** (cplx_sig_t*) - Required - Pointer to the generator structure.
- **output** (void*) - Required - Output array of length len*2 (supports S16_FIXED or F32_FLOAT).
- **len** (int32_t) - Required - Length of the output signal.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_dotprod_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Calculates the dot product of two floating-point vectors.

```APIDOC
## Function: dsps_dotprod_f32_ansi

### Description
Calculates the dot product of two floating-point arrays: *dest += (src1[i] * src2[i]); i= [0..N).

### Parameters
- **src1** (const float*) - Required - Source array 1
- **src2** (const float*) - Required - Source array 2
- **dest** (float*) - Required - Destination pointer
- **len** (int) - Required - Length of input arrays

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_biquad_gen_notch_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates coefficients for a notch 2nd order IIR filter (bi-quad).

```APIDOC
## esp_err_t dsps_biquad_gen_notch_f32(float *coeffs, float f, float gain, float qFactor)

### Description
Generates coefficients for a notch 2nd order IIR filter (bi-quad). The implementation uses ANSI C and is platform-independent.

### Parameters
- **coeffs** (float*) - Result coefficients (b0, b1, b2, a1, a2).
- **f** (float) - Filter notch frequency in range of 0..0.5 (normalized to sample frequency).
- **gain** (float) - Gain in stopband in dB.
- **qFactor** (float) - Q factor of the filter.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### esp_err_t dspm_mult_4x4x1_f32_ae32(const float *A, const float *B, float *C)

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Performs matrix multiplication for two floating point matrices 4x4 and 4x1 (C[1][4] = A[4][4] * B[4][1]), optimized for the ESP32 chip.

```APIDOC
## esp_err_t dspm_mult_4x4x1_f32_ae32(const float *A, const float *B, float *C)

### Description
Performs matrix multiplication for two floating point matrices 4x4 and 4x1. The result is stored in C[4][4].

### Parameters
- **A** (const float *) - Required - Input matrix A[4][4]
- **B** (const float *) - Required - Input matrix/vector B[4][1]
- **C** (float *) - Required - Result matrix/vector C[4][4]

### Return
- **ESP_OK** on success
- Error codes from DSP library on failure
```

--------------------------------

### dspi_dotprod_off_f32_ansi

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Calculates the dot product of two images with an input offset using ANSI C.

```APIDOC
## esp_err_t dspi_dotprod_off_f32_ansi(image2d_t *in_image, image2d_t *filter, float *out_value, int count_x, int count_y, float offset)

### Description
Calculates the dot product of two images with an input offset: out_value += (image[i] + offset) * src2[i].

### Parameters
- **in_image** (image2d_t*) - Input: Descriptor of the image.
- **filter** (image2d_t*) - Input: Descriptor of the filter.
- **out_value** (float*) - Output: Pointer to the output value.
- **count_x** (int) - Input: Amount of samples by X axis.
- **count_y** (int) - Input: Amount of samples by Y axis.
- **offset** (float) - Input: Input offset value.

### Return
- **ESP_OK** on success, or an error code from the DSP library.
```

--------------------------------

### dsps_biquad_gen_allpass360_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates coefficients for an allpass 360 degree IIR filter.

```APIDOC
## esp_err_t dsps_biquad_gen_allpass360_f32(float *coeffs, float f, float qFactor)

### Description
Generates coefficients for an allpass 2nd order IIR filter (bi-quad) with 360 degree phase shift.

### Parameters
- **coeffs** (float*) - Result coefficients.
- **f** (float) - Filter frequency in range of 0..0.5 (normalized to sample frequency).
- **qFactor** (float) - Q factor of the filter.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### float dsps_cplx_gen_phase_get(cplx_sig_t *cplx_gen)

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Retrieves the current phase of the complex signal generator.

```APIDOC
## float dsps_cplx_gen_phase_get(cplx_sig_t *cplx_gen)

### Description
Gets the phase of the complex generator. This function should be called after the generator structure has been initialized.

### Parameters
- **cplx_gen** (cplx_sig_t*) - Required - Pointer to the complex signal generator structure.

### Return
- **float** - The phase of the signal generator.
```

--------------------------------

### dsps_biquad_gen_hpf_f32

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Generates coefficients for a high-pass 2nd order IIR filter (bi-quad).

```APIDOC
## dsps_biquad_gen_hpf_f32

### Description
Generates coefficients for a high-pass 2nd order IIR filter (bi-quad). The implementation uses ANSI C and is platform-independent.

### Parameters
- **coeffs** (float*) - Required - Array to store result coefficients (b0, b1, b2, a1, a2).
- **f** (float) - Required - Filter cut-off frequency in range 0..0.5 (normalized to sample frequency).
- **qFactor** (float) - Required - Q factor of the filter.

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dspm_mult_s16_ansi

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Performs matrix multiplication for two signed 16-bit fixed point matrices: C[m][k] = (A[m][n] * B[n][k]) >> (15- shift).

```APIDOC
## esp_err_t dspm_mult_s16_ansi(const int16_t *A, const int16_t *B, int16_t *C, int m, int n, int k, int shift)

### Description
Performs matrix multiplication for two signed 16-bit fixed point matrices.

### Parameters
- **A** (const int16_t*) - Input matrix A[m][n]
- **B** (const int16_t*) - Input matrix B[n][k]
- **C** (int16_t*) - Result matrix C[m][k]
- **m** (int) - Matrix dimension
- **n** (int) - Matrix dimension
- **k** (int) - Matrix dimension
- **shift** (int) - Every result will be shifted and stored as 16-bit signed value.

### Response
- **Return** (esp_err_t) - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### dsps_addc_f32_ansi

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Adds a constant value to each element of an input float array.

```APIDOC
## esp_err_t dsps_addc_f32_ansi(const float *input, float *output, int len, float C, int step_in, int step_out)

### Description
Adds a constant value to the input array using the formula: x[i*step_out] = y[i*step_in] + C for i in [0..len).

### Parameters
- **input** (const float *) - Input array
- **output** (float *) - Output array
- **len** (int) - Amount of operations for arrays
- **C** (float) - Constant value
- **step_in** (int) - Step over input array
- **step_out** (int) - Step over output array

### Response
- **ESP_OK** - Success
- **Error Code** - One of the error codes from the DSP library
```

--------------------------------

### esp_err_t dspm_mult_4x4x4_f32_ae32(const float *A, const float *B, float *C)

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Performs matrix multiplication for two square 4x4 floating point matrices (C[4][4] = A[4][4] * B[4][4]), optimized for the ESP32 chip.

```APIDOC
## esp_err_t dspm_mult_4x4x4_f32_ae32(const float *A, const float *B, float *C)

### Description
Performs matrix multiplication for two square 4x4 floating point matrices. The result is stored in C[4][4].

### Parameters
- **A** (const float *) - Required - Input matrix A[4][4]
- **B** (const float *) - Required - Input matrix B[4][4]
- **C** (float *) - Required - Result matrix C[4][4]

### Return
- **ESP_OK** on success
- Error codes from DSP library on failure
```

--------------------------------

### dsps_dotprod_s16

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Calculates the dot product of two signed 16-bit vectors.

```APIDOC
## Function: dsps_dotprod_s16_ansi

### Description
Calculates the dot product of two signed 16-bit arrays: *dest += (src1[i] * src2[i]) >> (15-shift); i= [0..N). The _ansi version uses standard C, while _ae32 and _arp4 are optimized for specific hardware.

### Parameters
- **src1** (const int16_t*) - Required - Source array 1
- **src2** (const int16_t*) - Required - Source array 2
- **dest** (int16_t*) - Required - Destination pointer
- **len** (int) - Required - Length of input arrays
- **shift** (int8_t) - Required - Shift of the result

### Return
- **esp_err_t** - ESP_OK on success, or an error code from the DSP library.
```

--------------------------------

### Mat::dotProduct

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Calculates the dot product of two vectors.

```APIDOC
## static float dotProduct(Mat A, Mat B)

### Description
Returns the dot product of two vectors.

### Parameters
- **A** (Mat) - Required - Input vector A Nx1
- **B** (Mat) - Required - Input vector B Nx1

### Return
- **value** (float) - Dot product value
```

--------------------------------

### dsps_cplx2real_fc32_ansi_

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Converts FFT result to complex array for real input data.

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

### Description
Converts the FFT result of a complex FFT for real input to a complex output. Requires prior initialization via dsps_fft4r_init_fc32.

### Parameters
- **data** (float*) - Required - Input complex array and result buffer.
- **N** (int) - Required - Number of complex elements.
- **table** (float*) - Required - Pointer to sin/cos table.
- **table_size** (int) - Required - Size of the sin/cos table.
```

--------------------------------

### dsp_power_of_two

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Returns the power of two for values 2^N.

```APIDOC
## int dsp_power_of_two(int x)

### Description
Returns the power of 2 for values 2^N. The implementation uses ANSI C and is platform-independent.

### Parameters
- **x** (int) - The input value.

### Returns
- **int** - The power of two result.
```

--------------------------------

### dsps_mul_f32_ansi

Source: https://docs.espressif.com/projects/esp-dsp/en/latest/esp32/esp-dsp-apis.html

Multiplies two float arrays and stores the result in an output array.

```APIDOC
## esp_err_t dsps_mul_f32_ansi(const float *input1, const float *input2, float *output, int len, int step1, int step2, int step_out)

### Description
Multiplies one input array to another and stores the result in an output array using the formula: out[i*step_out] = input1[i*step1] * input2[i*step2] for i in [0..len).

### Parameters
- **input1** (const float *) - Input array 1
- **input2** (const float *) - Input array 2
- **output** (float *) - Output array
- **len** (int) - Amount of operations for arrays
- **step1** (int) - Step over input array 1
- **step2** (int) - Step over input array 2
- **step_out** (int) - Step over output array

### Response
- **ESP_OK** - Success
- **Error Code** - One of the error codes from the DSP library
```
Tokens:
Raw