dsps_resampler.h File Reference

#include "dsp_err.h"
#include "dsps_fir.h"

Include dependency graph for dsps_resampler.h:

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

Go to the source code of this file.

Data Structures
struct	dsps_resample_mr_s
	Data struct of f32 multi-rate resampler. More...
struct	dsps_resample_ph_s
	Data struct of f32 poly-phase resampler. More...

Typedefs
typedef struct dsps_resample_mr_s	dsps_resample_mr_t
	Data struct of f32 multi-rate resampler.
typedef struct dsps_resample_ph_s	dsps_resample_ph_t
	Data struct of f32 poly-phase resampler.

Functions
esp_err_t	dsps_resampler_mr_init (dsps_resample_mr_t *resampler, void *coeffs, int16_t length, int16_t interp, float samplerate_factor, int32_t fixed_point, int16_t shift)
	Initialize the multi-rate resampler.
int32_t	dsps_resampler_mr_exec (dsps_resample_mr_t *resampler, void *input, void *output, int32_t length, int32_t length_correction)
	Execute the multi-rate resampler.
void	dsps_resampler_mr_free (dsps_resample_mr_t *resampler)
	Free the multi-rate resampler.
esp_err_t	dsps_resampler_ph_init (dsps_resample_ph_t *resampler, float samplerate_factor)
	Initialize the poly-phase resampler.
int32_t	dsps_resampler_ph_exec (dsps_resample_ph_t *resampler, float *input, float *output, int32_t length)
	Execute the poly-phase resampler.

Typedef Documentation

dsps_resample_mr_t

typedef struct dsps_resample_mr_s dsps_resample_mr_t

Data struct of f32 multi-rate resampler.

This structure is used by a resampler internally. A user should access this structure only in case of extensions for the DSP Library. To initialize the resampler, use the dsps_resampler_mr_init() function. To execute the resampler, use the dsps_resampler_mr_exec() function. To free the resampler, use the dsps_resampler_mr_free() function.

dsps_resample_ph_t

typedef struct dsps_resample_ph_s dsps_resample_ph_t

Data struct of f32 poly-phase resampler.

This structure is used by a poly-phase resampler internally. A user should access this structure only in case of extensions for the DSP Library. To initialize the resampler, use the dsps_resampler_ph_init() function. To execute the resampler, use the dsps_resampler_ph_exec() function.

It is possible to correct the sample rate by adjust the phase parameter "on the fly".

Function Documentation

dsps_resampler_mr_exec()

int32_t dsps_resampler_mr_exec	(	dsps_resample_mr_t *	resampler,
		void *	input,
		void *	output,
		int32_t	length,
		int32_t	length_correction )

Execute the multi-rate resampler.

This function executes the multi-rate resampler. The input and output buffers can be the same. The function based on multi-rate FIR filter. The decimation factor is updated for each execution. The current decimation factor calculated as division of average input and average output sample rate. To correct the output sample rate, the length_correction parameter is used. To increase the output sample rate, the length_correction parameter should be positive. To decrease the output sample rate, the length_correction parameter should be negative. This parameter is used when the input and output sample rates are comes from different sources.

Parameters

resampler	Pointer to the resampler structure
input	Pointer to the input buffer
output	Pointer to the output buffer
length	Length of the input buffers
length_correction	Length correction for the current execution. Positive value increases the output sample rate, negative value decreases the output sample rate.

Returns

Length of the output buffer

Definition at line 47 of file dsps_resampler_mr.c.

{
    int32_t result = 0;
 
    if (resampler->fixed_point == 0) {
        ((fir_f32_t *)resampler->filter)->decim = resampler->active_decim;
    } else {
        ((fir_s16_t *)resampler->filter)->decim = resampler->active_decim;
    }
 
    result = resampler->dsps_firmr(resampler->filter, input, output, length);
 
    resampler->decim_avg_in = resampler->decim_avg_in * decim_avg_coeff + (float)length * (1 - decim_avg_coeff);
    resampler->decim_avg_out = resampler->decim_avg_out * decim_avg_coeff + (float)(result - length_correction) * (1 - decim_avg_coeff);
 
    if ((resampler->decim_avg_in * resampler->samplerate_factor) > (resampler->decim_avg_out)) {
        resampler->active_decim = resampler->decim_f;
    } else {
        resampler->active_decim = resampler->decim_c;
    }
    return result;
}

References dsps_resample_mr_s::active_decim, decim_avg_coeff, dsps_resample_mr_s::decim_avg_in, dsps_resample_mr_s::decim_avg_out, dsps_resample_mr_s::decim_c, dsps_resample_mr_s::decim_f, dsps_resample_mr_s::dsps_firmr, dsps_resample_mr_s::filter, dsps_resample_mr_s::fixed_point, and dsps_resample_mr_s::samplerate_factor.

dsps_resampler_mr_free()

void dsps_resampler_mr_free

(

dsps_resample_mr_t *

resampler

)

Free the multi-rate resampler.

Parameters

resampler

Pointer to the resampler structure

Definition at line 70 of file dsps_resampler_mr.c.

{
    if (resampler->fixed_point == 0) {
        dsps_fir_f32_free((fir_f32_t *)(resampler->filter));
    } else {
        dsps_fird_s16_aexx_free((fir_s16_t *)(resampler->filter));
    }
    free(resampler->filter);
}

References dsps_fir_f32_free(), dsps_fird_s16_aexx_free(), dsps_resample_mr_s::filter, and dsps_resample_mr_s::fixed_point.

Here is the call graph for this function:

dsps_resampler_mr_init()

esp_err_t dsps_resampler_mr_init	(	dsps_resample_mr_t *	resampler,
		void *	coeffs,
		int16_t	length,
		int16_t	interp,
		float	samplerate_factor,
		int32_t	fixed_point,
		int16_t	shift )

Initialize the multi-rate resampler.

Parameters

resampler	Pointer to the resampler structure
coeffs	Pointer to the filter coefficients (float or int16_t for fixed point)
length	Length of the filter coefficients
interp	Interpolation factor for the filter
samplerate_factor	Sample rate factor
fixed_point	Fixed point flag, 0 for float, 1 for fixed point
shift	Shift value for fixed point

Returns

ESP_OK on success, ESP_ERR_INVALID_ARG if the parameters are invalid

Definition at line 12 of file dsps_resampler_mr.c.

{
    esp_err_t ret = ESP_OK;
 
    if (samplerate_factor < 1) {
        return ESP_ERR_DSP_INVALID_PARAM;
    }
 
    resampler->fixed_point = fixed_point;
    resampler->samplerate_factor = samplerate_factor;
    float decimation = (float)interp / samplerate_factor;
    resampler->decim_f = floor(decimation);
    resampler->decim_c = ceil(decimation);
    resampler->active_decim = resampler->decim_c;
    resampler->decim_avg_in = 1;
    resampler->decim_avg_out = resampler->samplerate_factor;
 
    if (fixed_point == 0) {
        resampler->dsps_firmr = (int32_t (*)(void *, void *, void *, int32_t))dsps_firmr_f32;
        resampler->filter = (void *)malloc(sizeof(fir_f32_t));
 
        ret = dsps_firmr_init_f32((fir_f32_t *)resampler->filter, coeffs, NULL, length, interp, resampler->decim_c, 0);
    } else {
        resampler->dsps_firmr = (int32_t (*)(void *, void *, void *, int32_t))dsps_firmr_s16;
        resampler->filter = (void *)malloc(sizeof(fir_s16_t));
        ret = dsps_firmr_init_s16((fir_s16_t *)resampler->filter, coeffs, NULL, length, interp, resampler->decim_c, 0, shift);
    }
 
    if (ret != ESP_OK) {
        return ret;
    }
 
    return ret;
}

References dsps_resample_mr_s::active_decim, coeffs, dsps_resample_mr_s::decim_avg_in, dsps_resample_mr_s::decim_avg_out, dsps_resample_mr_s::decim_c, dsps_resample_mr_s::decim_f, dsps_resample_mr_s::dsps_firmr, dsps_firmr_f32, dsps_firmr_init_f32(), dsps_firmr_init_s16(), dsps_firmr_s16, ESP_ERR_DSP_INVALID_PARAM, ESP_OK, dsps_resample_mr_s::filter, dsps_resample_mr_s::fixed_point, and dsps_resample_mr_s::samplerate_factor.

Here is the call graph for this function:

dsps_resampler_ph_exec()

int32_t dsps_resampler_ph_exec	(	dsps_resample_ph_t *	resampler,
		float *	input,
		float *	output,
		int32_t	length )

Execute the poly-phase resampler.

Parameters

resampler	Pointer to the resampler structure
input	Pointer to the input buffer
output	Pointer to the output buffer
length	Length of the input buffer

Returns

Length of the output buffer

Definition at line 28 of file dsps_resampler_ph.c.

{
    int32_t result = 0;
    int input_pos = 0;
    float in_x[4];
 
    int in_pos = 0;
    for (int pos = resampler->delay_pos; pos < 4; pos++) {
        in_x[in_pos++] = resampler->delay[pos];
    }
    for (int pos = 0; pos < resampler->delay_pos; pos++) {
        in_x[in_pos++] = resampler->delay[pos];
    }
 
    while (input_pos < length) {
 
        float c0 = in_x[1];
        float c1 = 0.5 * (in_x[2] - in_x[0]);
        float c2 = in_x[0] - 2.5 * in_x[1] + 2 * in_x[2] - 0.5 * in_x[3];
        float c3 = 0.5 * (in_x[3] - in_x[0]) + 1.5 * (in_x[1] - in_x[2]);
 
        output[result] = c0 + resampler->phase * (c1 + resampler->phase * (c2 + resampler->phase * c3));
        result++;
        resampler->phase += resampler->step;
 
        while (resampler->phase >= 1) {
            resampler->phase -= 1;
            resampler->delay[resampler->delay_pos] = input[input_pos];
            resampler->delay_pos++;
            if (resampler->delay_pos >= 4) {
                resampler->delay_pos = 0;
            }
            input_pos++;
            in_pos = 0;
            for (int pos = resampler->delay_pos; pos < 4; pos++) {
                in_x[in_pos++] = resampler->delay[pos];
            }
            for (int pos = 0; pos < resampler->delay_pos; pos++) {
                in_x[in_pos++] = resampler->delay[pos];
            }
        }
    }
 
    return result;
}

References dsps_resample_ph_s::delay, dsps_resample_ph_s::delay_pos, dsps_resample_ph_s::phase, and dsps_resample_ph_s::step.

dsps_resampler_ph_init()

esp_err_t dsps_resampler_ph_init	(	dsps_resample_ph_t *	resampler,
		float	samplerate_factor )

Initialize the poly-phase resampler.

The poly-phase resampler is a implementation of the poly-phase Farrow filter that use cubic interpolation with 4 coefficients.

Parameters

resampler	Pointer to the resampler structure
samplerate_factor	Sample rate factor

Returns

ESP_OK on success, ESP_ERR_INVALID_ARG if the parameters are invalid

Definition at line 10 of file dsps_resampler_ph.c.

{
    esp_err_t ret = ESP_OK;
 
    if (samplerate_factor < 1) {
        return ESP_ERR_DSP_INVALID_PARAM;
    }
 
    for (int i = 0; i < 4; i++) {
        resampler->delay[i] = 0;
    }
    resampler->delay_pos = 0;
 
    resampler->step = 1.0f / samplerate_factor;
    resampler->phase = 0;
    return ret;
}

References dsps_resample_ph_s::delay, dsps_resample_ph_s::delay_pos, ESP_ERR_DSP_INVALID_PARAM, ESP_OK, dsps_resample_ph_s::phase, and dsps_resample_ph_s::step.