/* * Brickworks * * Copyright (C) 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_gain bw_hs1 bw_lp1 bw_math bw_mm2 bw_one_pole bw_peak * bw_satur bw_svf * }}} * description {{{ * Overdrive effect. * * Loosely inspired to the green "screaming" overdrive pedal. * }}} * changelog {{{ * * }}} */ #ifndef BW_DRIVE_H #define BW_DRIVE_H #include #ifdef __cplusplus extern "C" { #endif /*! api {{{ * #### bw_drive_coeffs * ```>>> */ typedef struct bw_drive_coeffs bw_drive_coeffs; /*! <<<``` * Coefficients and related. * * #### bw_drive_state * ```>>> */ typedef struct bw_drive_state bw_drive_state; /*! <<<``` * Internal state and related. * * #### bw_drive_init() * ```>>> */ static inline void bw_drive_init(bw_drive_coeffs *BW_RESTRICT coeffs); /*! <<<``` * Initializes input parameter values in `coeffs`. * * #### bw_drive_set_sample_rate() * ```>>> */ static inline void bw_drive_set_sample_rate(bw_drive_coeffs *BW_RESTRICT coeffs, float sample_rate); /*! <<<``` * Sets the `sample_rate` (Hz) value in `coeffs`. * * #### bw_drive_reset_coeffs() * ```>>> */ static inline void bw_drive_reset_coeffs(bw_drive_coeffs *BW_RESTRICT coeffs); /*! <<<``` * Resets coefficients in `coeffs` to assume their target values. * * #### bw_drive_reset_state() * ```>>> */ static inline void bw_drive_reset_state(const bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state *BW_RESTRICT state); /*! <<<``` * Resets the given `state` to its initial values using the given `coeffs`. * * #### bw_drive_update_coeffs_ctrl() * ```>>> */ static inline void bw_drive_update_coeffs_ctrl(bw_drive_coeffs *BW_RESTRICT coeffs); /*! <<<``` * Triggers control-rate update of coefficients in `coeffs`. * * #### bw_drive_update_coeffs_audio() * ```>>> */ static inline void bw_drive_update_coeffs_audio(bw_drive_coeffs *BW_RESTRICT coeffs); /*! <<<``` * Triggers audio-rate update of coefficients in `coeffs`. * * #### bw_drive_process1() * ```>>> */ static inline float bw_drive_process1(const bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state *BW_RESTRICT state, float x); /*! <<<``` * Processes one input sample `x` using `coeffs`, while using and updating * `state`. Returns the corresponding output sample. * * #### bw_drive_process() * ```>>> */ static inline void bw_drive_process(bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_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_drive_process_multi() * ```>>> */ static inline void bw_drive_process_multi(bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_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_drive_set_drive() * ```>>> */ static inline void bw_drive_set_drive(bw_drive_coeffs *BW_RESTRICT coeffs, float value); /*! <<<``` * Sets the overdrive (input gain, approximately) to the given `value` in * [`0.f`, `1.f`] in `coeffs`. * * Default value: `0.f`. * * #### bw_drive_set_tone() * ```>>> */ static inline void bw_drive_set_tone(bw_drive_coeffs *BW_RESTRICT coeffs, float value); /*! <<<``` * Sets the tone (filter) to the given `value` in [`0.f`, `1.f`] in `coeffs`. * * Default value: `0.5f`. * * #### bw_drive_set_volume() * ```>>> */ static inline void bw_drive_set_volume(bw_drive_coeffs *BW_RESTRICT coeffs, float value); /*! <<<``` * Sets the volume (output gain) to the given `value` in [`0.f`, `1.f`] in * `coeffs`. * * Default value: `1.f`. * }}} */ #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 #include #include #include #include #ifdef __cplusplus extern "C" { #endif struct bw_drive_coeffs { // Sub-components bw_svf_coeffs hp2_coeffs; bw_hs1_coeffs hs1_coeffs; bw_peak_coeffs peak_coeffs; bw_satur_coeffs satur_coeffs; bw_lp1_coeffs lp1_coeffs; bw_gain_coeffs gain_coeffs; }; struct bw_drive_state { // Sub-components bw_svf_state hp2_state; bw_hs1_state hs1_state; bw_peak_state peak_state; bw_satur_state satur_state; bw_lp1_state lp1_state; }; static inline void bw_drive_init(bw_drive_coeffs *BW_RESTRICT coeffs) { bw_svf_init(&coeffs->hp2_coeffs); bw_hs1_init(&coeffs->hs1_coeffs); bw_peak_init(&coeffs->peak_coeffs); bw_satur_init(&coeffs->satur_coeffs); bw_lp1_init(&coeffs->lp1_coeffs); bw_gain_init(&coeffs->gain_coeffs); bw_svf_set_cutoff(&coeffs->hp2_coeffs, 16.f); bw_hs1_set_cutoff(&coeffs->hs1_coeffs, 200.f); bw_hs1_set_high_gain_dB(&coeffs->hs1_coeffs, 20.f); bw_peak_set_peak_gain_dB(&coeffs->peak_coeffs, 0.f); bw_peak_set_cutoff(&coeffs->peak_coeffs, 500.f); bw_peak_set_bandwidth(&coeffs->peak_coeffs, 9.5f); bw_satur_set_gain(&coeffs->satur_coeffs, 1.5f); bw_satur_set_gain_compensation(&coeffs->satur_coeffs, 1); bw_lp1_set_cutoff(&coeffs->lp1_coeffs, 400.f + (5e3f - 400.f) * 0.125f); } static inline void bw_drive_set_sample_rate(bw_drive_coeffs *BW_RESTRICT coeffs, float sample_rate) { bw_svf_set_sample_rate(&coeffs->hp2_coeffs, sample_rate); bw_hs1_set_sample_rate(&coeffs->hs1_coeffs, sample_rate); bw_peak_set_sample_rate(&coeffs->peak_coeffs, sample_rate); bw_satur_set_sample_rate(&coeffs->satur_coeffs, sample_rate); bw_lp1_set_sample_rate(&coeffs->lp1_coeffs, sample_rate); bw_gain_set_sample_rate(&coeffs->gain_coeffs, sample_rate); bw_svf_reset_coeffs(&coeffs->hp2_coeffs); bw_hs1_reset_coeffs(&coeffs->hs1_coeffs); bw_satur_reset_coeffs(&coeffs->satur_coeffs); } static inline void bw_drive_reset_coeffs(bw_drive_coeffs *BW_RESTRICT coeffs) { bw_peak_reset_coeffs(&coeffs->peak_coeffs); bw_lp1_reset_coeffs(&coeffs->lp1_coeffs); bw_gain_reset_coeffs(&coeffs->gain_coeffs); } static inline void bw_drive_reset_state(const bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state *BW_RESTRICT state) { bw_svf_reset_state(&coeffs->hp2_coeffs, &state->hp2_state, 0.f); bw_hs1_reset_state(&coeffs->hs1_coeffs, &state->hs1_state, 0.f); bw_peak_reset_state(&coeffs->peak_coeffs, &state->peak_state, 0.f); bw_satur_reset_state(&coeffs->satur_coeffs, &state->satur_state); bw_lp1_reset_state(&coeffs->lp1_coeffs, &state->lp1_state, 0.f); } static inline void bw_drive_update_coeffs_ctrl(bw_drive_coeffs *BW_RESTRICT coeffs) { bw_peak_update_coeffs_ctrl(&coeffs->peak_coeffs); bw_lp1_update_coeffs_ctrl(&coeffs->lp1_coeffs); bw_gain_update_coeffs_ctrl(&coeffs->gain_coeffs); } static inline void bw_drive_update_coeffs_audio(bw_drive_coeffs *BW_RESTRICT coeffs) { bw_peak_update_coeffs_audio(&coeffs->peak_coeffs); bw_lp1_update_coeffs_audio(&coeffs->lp1_coeffs); bw_gain_update_coeffs_audio(&coeffs->gain_coeffs); } static inline float bw_drive_process1(const bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state *BW_RESTRICT state, float x) { float v_lp, v_hp, v_bp; bw_svf_process1(&coeffs->hp2_coeffs, &state->hp2_state, 0.316f * x, &v_lp, &v_bp, &v_hp); float y = bw_hs1_process1(&coeffs->hs1_coeffs, &state->hs1_state, v_hp); y = bw_peak_process1(&coeffs->peak_coeffs, &state->peak_state, y); y = v_hp + bw_satur_process1_comp(&coeffs->satur_coeffs, &state->satur_state, y - v_hp); y = bw_lp1_process1(&coeffs->lp1_coeffs, &state->lp1_state, y); return bw_gain_process1(&coeffs->gain_coeffs, y); } static inline void bw_drive_process(bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state *BW_RESTRICT state, const float *x, float *y, size_t n_samples) { bw_drive_update_coeffs_ctrl(coeffs); for (size_t i = 0; i < n_samples; i++) { bw_drive_update_coeffs_audio(coeffs); y[i] = bw_drive_process1(coeffs, state, x[i]); } } static inline void bw_drive_process_multi(bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state *BW_RESTRICT const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) { bw_drive_update_coeffs_ctrl(coeffs); for (size_t i = 0; i < n_samples; i++) { bw_drive_update_coeffs_audio(coeffs); for (size_t j = 0; j < n_channels; j++) y[j][i] = bw_drive_process1(coeffs, state[j], x[j][i]); } } static inline void bw_drive_set_drive(bw_drive_coeffs *BW_RESTRICT coeffs, float value) { bw_peak_set_peak_gain_dB(&coeffs->peak_coeffs, 20.f * value); } static inline void bw_drive_set_tone(bw_drive_coeffs *BW_RESTRICT coeffs, float value) { bw_lp1_set_cutoff(&coeffs->lp1_coeffs, 400.f + (5e3f - 400.f) * value * value * value); } static inline void bw_drive_set_volume(bw_drive_coeffs *BW_RESTRICT coeffs, float value) { bw_gain_set_gain_lin(&coeffs->gain_coeffs, value * value * value); } #ifdef __cplusplus } #include namespace Brickworks { /*** Public C++ API ***/ /*! api_cpp {{{ * ##### Brickworks::Drive * ```>>> */ template class Drive { public: Drive(); void setSampleRate(float sampleRate); void reset(); void process( const float * const *x, float * const *y, size_t nSamples); void process( std::array x, std::array y, size_t nSamples); void setDrive(float value); void setTone(float value); void setVolume(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_drive_coeffs coeffs; bw_drive_state states[N_CHANNELS]; bw_drive_state *BW_RESTRICT statesP[N_CHANNELS]; }; template inline Drive::Drive() { bw_drive_init(&coeffs); for (size_t i = 0; i < N_CHANNELS; i++) statesP[i] = states + i; } template inline void Drive::setSampleRate(float sampleRate) { bw_drive_set_sample_rate(&coeffs, sampleRate); } template inline void Drive::reset() { bw_drive_reset_coeffs(&coeffs); for (size_t i = 0; i < N_CHANNELS; i++) bw_drive_reset_state(&coeffs, states + i); } template inline void Drive::process( const float * const *x, float * const *y, size_t nSamples) { bw_drive_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples); } template inline void Drive::process( std::array x, std::array y, size_t nSamples) { process(x.data(), y.data(), nSamples); } template inline void Drive::setDrive(float value) { bw_drive_set_drive(&coeffs, value); } template inline void Drive::setTone(float value) { bw_drive_set_tone(&coeffs, value); } template inline void Drive::setVolume(float value) { bw_drive_set_volume(&coeffs, value); } } #endif #endif