/* * Brickworks * * Copyright (C) 2022, 2023 Orastron Srl unipersonale * * Brickworks is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, version 3 of the License. * * Brickworks is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Brickworks. If not, see . * * File author: Stefano D'Angelo */ /*! * module_type {{{ dsp }}} * version {{{ 1.0.0 }}} * requires {{{ bw_common bw_math bw_one_pole }}} * description {{{ * First-order lowpass filter (6 dB/oct) with unitary DC gain. * * This is better suited to filtering actual audio than * [bw_one_pole](bw_one_pole). * }}} * changelog {{{ * * }}} */ #ifndef BW_LP1_H #define BW_LP1_H #include #ifdef __cplusplus extern "C" { #endif /*! api {{{ * #### bw_lp1_coeffs * ```>>> */ typedef struct bw_lp1_coeffs bw_lp1_coeffs; /*! <<<``` * Coefficients and related. * * #### bw_lp1_state * ```>>> */ typedef struct bw_lp1_state bw_lp1_state; /*! <<<``` * Internal state and related. * * #### bw_lp1_init() * ```>>> */ static inline void bw_lp1_init(bw_lp1_coeffs *BW_RESTRICT coeffs); /*! <<<``` * Initializes input parameter values in `coeffs`. * * #### bw_lp1_set_sample_rate() * ```>>> */ static inline void bw_lp1_set_sample_rate(bw_lp1_coeffs *BW_RESTRICT coeffs, float sample_rate); /*! <<<``` * Sets the `sample_rate` (Hz) value in `coeffs`. * * #### bw_lp1_reset_coeffs() * ```>>> */ static inline void bw_lp1_reset_coeffs(bw_lp1_coeffs *BW_RESTRICT coeffs); /*! <<<``` * Resets coefficients in `coeffs` to assume their target values. * * #### bw_lp1_reset_state() * ```>>> */ static inline void bw_lp1_reset_state(const bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state *BW_RESTRICT state, float x_0); /*! <<<``` * Resets the given `state` to its initial values using the given `coeffs` * and the quiescent/initial input value `x_0`. * * #### bw_lp1_update_coeffs_ctrl() * ```>>> */ static inline void bw_lp1_update_coeffs_ctrl(bw_lp1_coeffs *BW_RESTRICT coeffs); /*! <<<``` * Triggers control-rate update of coefficients in `coeffs`. * * #### bw_lp1_update_coeffs_audio() * ```>>> */ static inline void bw_lp1_update_coeffs_audio(bw_lp1_coeffs *BW_RESTRICT coeffs); /*! <<<``` * Triggers audio-rate update of coefficients in `coeffs`. * * #### bw_lp1_process1() * ```>>> */ static inline float bw_lp1_process1(const bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state *BW_RESTRICT state, float x); /*! <<<``` * Processes one input sample `x` using `coeffs`, while using and updating * `state`. Returns the corresponding output sample. * * #### bw_lp1_process() * ```>>> */ static inline void bw_lp1_process(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state *BW_RESTRICT state, const float *x, float *y, size_t n_samples); /*! <<<``` * Processes the first `n_samples` of the input buffer `x` and fills the * first `n_samples` of the output buffer `y`, while using and updating both * `coeffs` and `state` (control and audio rate). * * #### bw_lp1_process_multi() * ```>>> */ static inline void bw_lp1_process_multi(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state *BW_RESTRICT const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples); /*! <<<``` * Processes the first `n_samples` of the `n_channels` input buffers `x` and * fills the first `n_samples` of the `n_channels` output buffers `y`, while * using and updating both the common `coeffs` and each of the `n_channels` * `state`s (control and audio rate). * * #### bw_lp1_set_cutoff() * ```>>> */ static inline void bw_lp1_set_cutoff(bw_lp1_coeffs *BW_RESTRICT coeffs, float value); /*! <<<``` * Sets the cutoff frequency `value` (Hz) in `coeffs`. * * Default value: `1e3f`. * * #### bw_lp1_set_prewarp_at_cutoff() * ```>>> */ static inline void bw_lp1_set_prewarp_at_cutoff(bw_lp1_coeffs *BW_RESTRICT coeffs, char value); /*! <<<``` * Sets whether bilinear transform prewarping frequency should match the * cutoff frequency (non-`0`) or not (`0`). * * Default value: non-`0` (on). * * #### bw_lp1_set_prewarp_freq() * ```>>> */ static inline void bw_lp1_set_prewarp_freq(bw_lp1_coeffs *BW_RESTRICT coeffs, float value); /*! <<<``` * Sets the prewarping frequency `value` (Hz) in `coeffs`. * * Only used when the prewarp\_at\_cutoff parameter is off. * * Default value: `1e3f`. * }}} */ #ifdef __cplusplus } #endif /*** Implementation ***/ /* WARNING: This part of the file is not part of the public API. Its content may * change at any time in future versions. Please, do not use it directly. */ #include #include #ifdef __cplusplus extern "C" { #endif struct bw_lp1_coeffs { // Sub-components bw_one_pole_coeffs smooth_coeffs; bw_one_pole_state smooth_cutoff_state; bw_one_pole_state smooth_prewarp_freq_state; // Coefficients float t_k; float prewarp_k; float t; float X_x; float X_X_z1; float y_X; // Parameters float cutoff; float prewarp_freq; }; struct bw_lp1_state { float y_z1; float X_z1; }; static inline void bw_lp1_init(bw_lp1_coeffs *BW_RESTRICT coeffs) { bw_one_pole_init(&coeffs->smooth_coeffs); bw_one_pole_set_tau(&coeffs->smooth_coeffs, 0.005f); bw_one_pole_set_sticky_thresh(&coeffs->smooth_coeffs, 1e-3f); coeffs->cutoff = 1e3f; coeffs->prewarp_freq = 1e3f; coeffs->prewarp_k = 1.f; } static inline void bw_lp1_set_sample_rate(bw_lp1_coeffs *BW_RESTRICT coeffs, float sample_rate) { bw_one_pole_set_sample_rate(&coeffs->smooth_coeffs, sample_rate); bw_one_pole_reset_coeffs(&coeffs->smooth_coeffs); coeffs->t_k = 3.141592653589793f / sample_rate; } static inline void bw_lp1_do_update_coeffs(bw_lp1_coeffs *BW_RESTRICT coeffs, char force) { const float prewarp_freq = coeffs->prewarp_freq + coeffs->prewarp_k * (coeffs->cutoff - coeffs->prewarp_freq); float prewarp_freq_cur = bw_one_pole_get_y_z1(&coeffs->smooth_prewarp_freq_state); float cutoff_cur = bw_one_pole_get_y_z1(&coeffs->smooth_cutoff_state); const char prewarp_freq_changed = force || prewarp_freq != prewarp_freq_cur; const char cutoff_changed = force || coeffs->cutoff != cutoff_cur; if (prewarp_freq_changed || cutoff_changed) { if (prewarp_freq_changed) { prewarp_freq_cur = bw_one_pole_process1_sticky_rel(&coeffs->smooth_coeffs, &coeffs->smooth_prewarp_freq_state, prewarp_freq); coeffs->t = bw_tanf(coeffs->t_k * prewarp_freq_cur); } if (cutoff_changed) { cutoff_cur = bw_one_pole_process1_sticky_rel(&coeffs->smooth_coeffs, &coeffs->smooth_cutoff_state, coeffs->cutoff); coeffs->y_X = bw_rcpf(cutoff_cur); } const float k = cutoff_cur * bw_rcpf(cutoff_cur * coeffs->t + prewarp_freq_cur); coeffs->X_x = k * prewarp_freq_cur; coeffs->X_X_z1 = k * coeffs->t; } } static inline void bw_lp1_reset_coeffs(bw_lp1_coeffs *BW_RESTRICT coeffs) { bw_one_pole_reset_state(&coeffs->smooth_coeffs, &coeffs->smooth_cutoff_state, coeffs->cutoff); bw_one_pole_reset_state(&coeffs->smooth_coeffs, &coeffs->smooth_prewarp_freq_state, coeffs->prewarp_freq + coeffs->prewarp_k * (coeffs->cutoff - coeffs->prewarp_freq)); bw_lp1_do_update_coeffs(coeffs, 1); } static inline void bw_lp1_reset_state(const bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state *BW_RESTRICT state, float x_0) { (void)coeffs; state->y_z1 = x_0; state->X_z1 = 0.f; } static inline void bw_lp1_update_coeffs_ctrl(bw_lp1_coeffs *BW_RESTRICT coeffs) { (void)coeffs; } static inline void bw_lp1_update_coeffs_audio(bw_lp1_coeffs *BW_RESTRICT coeffs) { bw_lp1_do_update_coeffs(coeffs, 0); } static inline float bw_lp1_process1(const bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state *BW_RESTRICT state, float x) { const float X = coeffs->X_x * (x - state->y_z1) - coeffs->X_X_z1 * state->X_z1; const float y = x - coeffs->y_X * X; state->y_z1 = y; state->X_z1 = X; return y; } static inline void bw_lp1_process(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state *BW_RESTRICT state, const float *x, float *y, size_t n_samples) { for (size_t i = 0; i < n_samples; i++) { bw_lp1_update_coeffs_audio(coeffs); y[i] = bw_lp1_process1(coeffs, state, x[i]); } } static inline void bw_lp1_process_multi(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state *BW_RESTRICT const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) { for (size_t i = 0; i < n_samples; i++) { bw_lp1_update_coeffs_audio(coeffs); for (size_t j = 0; j < n_channels; j++) y[j][i] = bw_lp1_process1(coeffs, state[j], x[j][i]); } } static inline void bw_lp1_set_cutoff(bw_lp1_coeffs *BW_RESTRICT coeffs, float value) { coeffs->cutoff = value; } static inline void bw_lp1_set_prewarp_at_cutoff(bw_lp1_coeffs *BW_RESTRICT coeffs, char value) { coeffs->prewarp_k = value ? 1.f : 0.f; } static inline void bw_lp1_set_prewarp_freq(bw_lp1_coeffs *BW_RESTRICT coeffs, float value) { coeffs->prewarp_freq = value; } #ifdef __cplusplus } #include namespace Brickworks { /*** Public C++ API ***/ /*! api_cpp {{{ * ##### Brickworks::LP1 * ```>>> */ template class LP1 { public: LP1(); void setSampleRate(float sampleRate); void reset(float x_0 = 0.f); void process( const float * const *x, float * const *y, size_t nSamples); void process( std::array x, std::array y, size_t nSamples); void setCutoff(float value); void setPrewarpAtCutoff(bool value); void setPrewarpFreq(float value); /*! <<<... * } * ``` * }}} */ /*** Implementation ***/ /* WARNING: This part of the file is not part of the public API. Its content may * change at any time in future versions. Please, do not use it directly. */ private: bw_lp1_coeffs coeffs; bw_lp1_state states[N_CHANNELS]; bw_lp1_state *BW_RESTRICT statesP[N_CHANNELS]; }; template inline LP1::LP1() { bw_lp1_init(&coeffs); for (size_t i = 0; i < N_CHANNELS; i++) statesP[i] = states + i; } template inline void LP1::setSampleRate(float sampleRate) { bw_lp1_set_sample_rate(&coeffs, sampleRate); } template inline void LP1::reset(float x_0) { bw_lp1_reset_coeffs(&coeffs); for (size_t i = 0; i < N_CHANNELS; i++) bw_lp1_reset_state(&coeffs, states + i, x_0); } template inline void LP1::process( const float * const *x, float * const *y, size_t nSamples) { bw_lp1_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples); } template inline void LP1::process( std::array x, std::array y, size_t nSamples) { process(x.data(), y.data(), nSamples); } template inline void LP1::setCutoff(float value) { bw_lp1_set_cutoff(&coeffs, value); } template inline void LP1::setPrewarpAtCutoff(bool value) { bw_lp1_set_prewarp_at_cutoff(&coeffs, value); } template inline void LP1::setPrewarpFreq(float value) { bw_lp1_set_prewarp_freq(&coeffs, value); } } #endif #endif