diff --git a/examples/fx_fuzz/src/bw_example_fx_fuzz.c b/examples/fx_fuzz/src/bw_example_fx_fuzz.c index ed918da..6dc3221 100644 --- a/examples/fx_fuzz/src/bw_example_fx_fuzz.c +++ b/examples/fx_fuzz/src/bw_example_fx_fuzz.c @@ -32,7 +32,7 @@ void bw_example_fx_fuzz_set_sample_rate(bw_example_fx_fuzz *instance, float samp void bw_example_fx_fuzz_reset(bw_example_fx_fuzz *instance) { bw_fuzz_reset_coeffs(&instance->fuzz_coeffs); - bw_fuzz_reset_state(&instance->fuzz_coeffs, &instance->fuzz_state); + bw_fuzz_reset_state(&instance->fuzz_coeffs, &instance->fuzz_state, 0.f); bw_src_int_reset_state(&instance->src_up_coeffs, &instance->src_up_state, 0.f); bw_src_int_reset_state(&instance->src_down_coeffs, &instance->src_down_state, 0.f); } diff --git a/examples/fx_fuzz/vst3/Makefile b/examples/fx_fuzz/vst3/Makefile index ca9e501..b4a3eaf 100644 --- a/examples/fx_fuzz/vst3/Makefile +++ b/examples/fx_fuzz/vst3/Makefile @@ -4,3 +4,6 @@ NAME := bw_example_fx_fuzz SOURCES = ${SOURCES_COMMON} ${ROOT_DIR}/../src/bw_example_fx_fuzz.c include ${ROOT_DIR}/../../common/vst3/vst3.mk + +CXXFLAGS += -DRELEASE=1 -DNDEBUG -DBW_NO_DEBUG +#CXXFLAGS += -DDEVELOPMENT=1 -DBW_DEBUG_DEEP diff --git a/examples/fxpp_fuzz/vst3/Makefile b/examples/fxpp_fuzz/vst3/Makefile index e95c6f6..a43657c 100644 --- a/examples/fxpp_fuzz/vst3/Makefile +++ b/examples/fxpp_fuzz/vst3/Makefile @@ -4,3 +4,6 @@ NAME := bw_example_fxpp_fuzz SOURCES = ${SOURCES_COMMON} ${ROOT_DIR}/../src/bw_example_fxpp_fuzz.cpp include ${ROOT_DIR}/../../common/vst3/vst3.mk + +CXXFLAGS += -DRELEASE=1 -DNDEBUG -DBW_NO_DEBUG +#CXXFLAGS += -DDEVELOPMENT=1 -DBW_DEBUG_DEEP diff --git a/include/bw_fuzz.h b/include/bw_fuzz.h index 90a785c..b4fa71c 100644 --- a/include/bw_fuzz.h +++ b/include/bw_fuzz.h @@ -36,6 +36,12 @@ * * *
  • Version 0.6.0: @@ -85,50 +93,86 @@ typedef struct bw_fuzz_state bw_fuzz_state; * * #### bw_fuzz_init() * ```>>> */ -static inline void bw_fuzz_init(bw_fuzz_coeffs *BW_RESTRICT coeffs); +static inline void bw_fuzz_init( + bw_fuzz_coeffs * BW_RESTRICT coeffs); /*! <<<``` * Initializes input parameter values in `coeffs`. * * #### bw_fuzz_set_sample_rate() * ```>>> */ -static inline void bw_fuzz_set_sample_rate(bw_fuzz_coeffs *BW_RESTRICT coeffs, float sample_rate); +static inline void bw_fuzz_set_sample_rate( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + float sample_rate); /*! <<<``` * Sets the `sample_rate` (Hz) value in `coeffs`. * * #### bw_fuzz_reset_coeffs() * ```>>> */ -static inline void bw_fuzz_reset_coeffs(bw_fuzz_coeffs *BW_RESTRICT coeffs); +static inline void bw_fuzz_reset_coeffs( + bw_fuzz_coeffs * BW_RESTRICT coeffs); /*! <<<``` * Resets coefficients in `coeffs` to assume their target values. * * #### bw_fuzz_reset_state() * ```>>> */ -static inline void bw_fuzz_reset_state(const bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state *BW_RESTRICT state); +static inline float bw_fuzz_reset_state( + const bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_state * BW_RESTRICT state, + float x_0); /*! <<<``` - * Resets the given `state` to its initial values using the given `coeffs`. + * Resets the given `state` to its initial values using the given `coeffs` + * and the initial input value `x_0`. + * + * Returns the corresponding initial output value. + * + * #### bw_fuzz_reset_state_multi() + * ```>>> */ +static inline void bw_fuzz_reset_state_multi( + const bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_state * BW_RESTRICT const * BW_RESTRICT state, + const float * x_0, + float * y_0, + size_t n_channels); +/*! <<<``` + * Resets each of the `n_channels` `state`s to its initial values using the + * given `coeffs` and the corresponding initial input value in the `x_0` + * array. + * + * The corresponding initial output values are written into the `y_0` array, + * if not `NULL`. * * #### bw_fuzz_update_coeffs_ctrl() * ```>>> */ -static inline void bw_fuzz_update_coeffs_ctrl(bw_fuzz_coeffs *BW_RESTRICT coeffs); +static inline void bw_fuzz_update_coeffs_ctrl( + bw_fuzz_coeffs * BW_RESTRICT coeffs); /*! <<<``` * Triggers control-rate update of coefficients in `coeffs`. * * #### bw_fuzz_update_coeffs_audio() * ```>>> */ -static inline void bw_fuzz_update_coeffs_audio(bw_fuzz_coeffs *BW_RESTRICT coeffs); +static inline void bw_fuzz_update_coeffs_audio( + bw_fuzz_coeffs * BW_RESTRICT coeffs); /*! <<<``` * Triggers audio-rate update of coefficients in `coeffs`. * * #### bw_fuzz_process1() * ```>>> */ -static inline float bw_fuzz_process1(const bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state *BW_RESTRICT state, float x); +static inline float bw_fuzz_process1( + const bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_state * BW_RESTRICT state, + float x); /*! <<<``` * Processes one input sample `x` using `coeffs`, while using and updating * `state`. Returns the corresponding output sample. * * #### bw_fuzz_process() * ```>>> */ -static inline void bw_fuzz_process(bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state *BW_RESTRICT state, const float *x, float *y, size_t n_samples); +static inline void bw_fuzz_process( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_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 @@ -136,7 +180,13 @@ static inline void bw_fuzz_process(bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_s * * #### bw_fuzz_process_multi() * ```>>> */ -static inline void bw_fuzz_process_multi(bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state *BW_RESTRICT const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples); +static inline void bw_fuzz_process_multi( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_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 @@ -145,21 +195,56 @@ static inline void bw_fuzz_process_multi(bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_ * * #### bw_fuzz_set_fuzz() * ```>>> */ -static inline void bw_fuzz_set_fuzz(bw_fuzz_coeffs *BW_RESTRICT coeffs, float value); +static inline void bw_fuzz_set_fuzz( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + float value); /*! <<<``` - * Sets the fuzz (input gain, approximately) to the given `value` in [`0.f`, - * `1.f`] in `coeffs`. + * Sets the fuzz (input gain, approximately) to the given `value` in + * `coeffs`. + * + * Valid range: [`0.f` (low fuzz), `1.f` (high fuzz)]. * * Default value: `0.f`. * * #### bw_fuzz_set_volume() * ```>>> */ -static inline void bw_fuzz_set_volume(bw_fuzz_coeffs *BW_RESTRICT coeffs, float value); +static inline void bw_fuzz_set_volume( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + float value); /*! <<<``` - * Sets the volume (output gain) to the given `value` in [`0.f`, `1.f`] in - * `coeffs`. + * Sets the volume (output gain) to the given `value` in `coeffs`. + * + * Valid range: [`0.f` (silence), `1.f` (max volume)]. * * Default value: `1.f`. + * + * #### bw_fuzz_coeffs_is_valid() + * ```>>> */ +static inline char bw_fuzz_coeffs_is_valid( + const bw_fuzz_coeffs * BW_RESTRICT coeffs); +/*! <<<``` + * Tries to determine whether `coeffs` is valid and returns non-`0` if it + * seems to be the case and `0` if it is certainly not. False positives are + * possible, false negatives are not. + * + * `coeffs` must at least point to a readable memory block of size greater + * than or equal to that of `bw_fuzz_coeffs`. + * + * #### bw_fuzz_state_is_valid() + * ```>>> */ +static inline char bw_fuzz_state_is_valid( + const bw_fuzz_coeffs * BW_RESTRICT coeffs, + const bw_fuzz_state * BW_RESTRICT state); +/*! <<<``` + * Tries to determine whether `state` is valid and returns non-`0` if it + * seems to be the case and `0` if it is certainly not. False positives are + * possible, false negatives are not. + * + * If `coeffs` is not `NULL` extra cross-checks might be performed (`state` + * is supposed to be associated to `coeffs`). + * + * `state` must at least point to a readable memory block of size greater + * than or equal to that of `bw_fuzz_state`. * }}} */ #ifdef __cplusplus @@ -182,17 +267,37 @@ static inline void bw_fuzz_set_volume(bw_fuzz_coeffs *BW_RESTRICT coeffs, float extern "C" { #endif +#ifdef BW_DEBUG_DEEP +enum bw_fuzz_coeffs_state { + bw_fuzz_coeffs_state_invalid, + bw_fuzz_coeffs_state_init, + bw_fuzz_coeffs_state_set_sample_rate, + bw_fuzz_coeffs_state_reset_coeffs +}; +#endif + struct bw_fuzz_coeffs { +#ifdef BW_DEBUG_DEEP + uint32_t hash; + enum bw_fuzz_coeffs_state state; + uint32_t reset_id; +#endif + // Sub-components - bw_hp1_coeffs hp1_in_coeffs; - bw_svf_coeffs lp2_coeffs; - bw_peak_coeffs peak_coeffs; - bw_satur_coeffs satur_coeffs; - bw_hp1_coeffs hp1_out_coeffs; - bw_gain_coeffs gain_coeffs; + bw_hp1_coeffs hp1_in_coeffs; + bw_svf_coeffs lp2_coeffs; + bw_peak_coeffs peak_coeffs; + bw_satur_coeffs satur_coeffs; + bw_hp1_coeffs hp1_out_coeffs; + bw_gain_coeffs gain_coeffs; }; struct bw_fuzz_state { +#ifdef BW_DEBUG_DEEP + uint32_t hash; + uint32_t coeffs_reset_id; +#endif + // Sub-components bw_hp1_state hp1_in_state; bw_svf_state lp2_1_state; @@ -202,7 +307,10 @@ struct bw_fuzz_state { bw_hp1_state hp1_out_state; }; -static inline void bw_fuzz_init(bw_fuzz_coeffs *BW_RESTRICT coeffs) { +static inline void bw_fuzz_init( + bw_fuzz_coeffs * BW_RESTRICT coeffs) { + BW_ASSERT(coeffs != NULL); + bw_hp1_init(&coeffs->hp1_in_coeffs); bw_svf_init(&coeffs->lp2_coeffs); bw_peak_init(&coeffs->peak_coeffs); @@ -215,9 +323,24 @@ static inline void bw_fuzz_init(bw_fuzz_coeffs *BW_RESTRICT coeffs) { bw_peak_set_bandwidth(&coeffs->peak_coeffs, 6.6f); bw_satur_set_bias(&coeffs->satur_coeffs, 0.145f); bw_hp1_set_cutoff(&coeffs->hp1_out_coeffs, 30.f); + +#ifdef BW_DEBUG_DEEP + coeffs->hash = bw_hash_sdbm("bw_fuzz_coeffs"); + coeffs->state = bw_fuzz_coeffs_state_init; + coeffs->reset_id = coeffs->hash + 1; +#endif + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state == bw_fuzz_coeffs_state_init); } -static inline void bw_fuzz_set_sample_rate(bw_fuzz_coeffs *BW_RESTRICT coeffs, float sample_rate) { +static inline void bw_fuzz_set_sample_rate( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + float sample_rate) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_init); + BW_ASSERT(bw_is_finite(sample_rate) && sample_rate > 0.f); + bw_hp1_set_sample_rate(&coeffs->hp1_in_coeffs, sample_rate); bw_svf_set_sample_rate(&coeffs->lp2_coeffs, sample_rate); bw_peak_set_sample_rate(&coeffs->peak_coeffs, sample_rate); @@ -228,66 +351,262 @@ static inline void bw_fuzz_set_sample_rate(bw_fuzz_coeffs *BW_RESTRICT coeffs, f bw_svf_reset_coeffs(&coeffs->lp2_coeffs); bw_satur_reset_coeffs(&coeffs->satur_coeffs); bw_hp1_reset_coeffs(&coeffs->hp1_out_coeffs); + +#ifdef BW_DEBUG_DEEP + coeffs->state = bw_fuzz_coeffs_state_set_sample_rate; +#endif + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state == bw_fuzz_coeffs_state_set_sample_rate); } -static inline void bw_fuzz_reset_coeffs(bw_fuzz_coeffs *BW_RESTRICT coeffs) { +static inline void bw_fuzz_reset_coeffs( + bw_fuzz_coeffs * BW_RESTRICT coeffs) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_set_sample_rate); + bw_peak_reset_coeffs(&coeffs->peak_coeffs); bw_gain_reset_coeffs(&coeffs->gain_coeffs); + +#ifdef BW_DEBUG_DEEP + coeffs->state = bw_fuzz_coeffs_state_reset_coeffs; + coeffs->reset_id++; +#endif + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state == bw_fuzz_coeffs_state_reset_coeffs); } -static inline void bw_fuzz_reset_state(const bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state *BW_RESTRICT state) { - bw_hp1_reset_state(&coeffs->hp1_in_coeffs, &state->hp1_in_state, 0.f); - bw_svf_reset_state(&coeffs->lp2_coeffs, &state->lp2_1_state, 0.f); - bw_svf_reset_state(&coeffs->lp2_coeffs, &state->lp2_2_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_hp1_reset_state(&coeffs->hp1_out_coeffs, &state->hp1_out_state, 0.f); +static inline float bw_fuzz_reset_state( + const bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_state * BW_RESTRICT state, + float x_0) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT(state != NULL); + BW_ASSERT(bw_is_finite(x_0)); + + float y = bw_hp1_reset_state(&coeffs->hp1_in_coeffs, &state->hp1_in_state, x_0); + float v_lp, v_hp, v_bp; + bw_svf_reset_state(&coeffs->lp2_coeffs, &state->lp2_1_state, y, &v_lp, &v_bp, &v_hp); + bw_svf_reset_state(&coeffs->lp2_coeffs, &state->lp2_2_state, v_lp, &v_lp, &v_bp, &v_hp); + y = bw_peak_reset_state(&coeffs->peak_coeffs, &state->peak_state, v_lp); + y = bw_satur_reset_state(&coeffs->satur_coeffs, &state->satur_state, y); + y = bw_hp1_reset_state(&coeffs->hp1_out_coeffs, &state->hp1_out_state, y); + y = bw_gain_get_gain_cur(&coeffs->gain_coeffs) * y; + +#ifdef BW_DEBUG_DEEP + state->hash = bw_hash_sdbm("bw_fuzz_state"); + state->coeffs_reset_id = coeffs->reset_id; +#endif + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT_DEEP(bw_fuzz_state_is_valid(coeffs, state)); + BW_ASSERT(bw_is_finite(y)); + + return y; } -static inline void bw_fuzz_update_coeffs_ctrl(bw_fuzz_coeffs *BW_RESTRICT coeffs) { +static inline void bw_fuzz_reset_state_multi( + const bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_state * BW_RESTRICT const * BW_RESTRICT state, + const float * x_0, + float * y_0, + size_t n_channels) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT(state != NULL); + BW_ASSERT(x_0 != NULL); + + if (y_0 != NULL) + for (size_t i = 0; i < n_channels; i++) + y_0[i] = bw_fuzz_reset_state(coeffs, state[i], x_0[i]); + else + for (size_t i = 0; i < n_channels; i++) + bw_fuzz_reset_state(coeffs, state[i], x_0[i]); + + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT_DEEP(y_0 != NULL ? bw_has_only_finite(y_0, n_channels) : 1); +} + +static inline void bw_fuzz_update_coeffs_ctrl( + bw_fuzz_coeffs * BW_RESTRICT coeffs) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + bw_peak_update_coeffs_ctrl(&coeffs->peak_coeffs); bw_gain_update_coeffs_ctrl(&coeffs->gain_coeffs); + + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); } -static inline void bw_fuzz_update_coeffs_audio(bw_fuzz_coeffs *BW_RESTRICT coeffs) { +static inline void bw_fuzz_update_coeffs_audio( + bw_fuzz_coeffs * BW_RESTRICT coeffs) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + bw_peak_update_coeffs_audio(&coeffs->peak_coeffs); bw_gain_update_coeffs_audio(&coeffs->gain_coeffs); + + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); } -static inline float bw_fuzz_process1(const bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state *BW_RESTRICT state, float x) { +static inline float bw_fuzz_process1( + const bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_state * BW_RESTRICT state, + float x) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT(state != NULL); + BW_ASSERT_DEEP(bw_fuzz_state_is_valid(coeffs, state)); + BW_ASSERT(bw_is_finite(x)); + float y = bw_hp1_process1(&coeffs->hp1_in_coeffs, &state->hp1_in_state, x); float v_lp, v_hp, v_bp; - bw_svf_process1(&coeffs->lp2_coeffs, &state->lp2_1_state, x, &v_lp, &v_bp, &v_hp); + bw_svf_process1(&coeffs->lp2_coeffs, &state->lp2_1_state, y, &v_lp, &v_bp, &v_hp); bw_svf_process1(&coeffs->lp2_coeffs, &state->lp2_2_state, v_lp, &v_lp, &v_bp, &v_hp); y = bw_peak_process1(&coeffs->peak_coeffs, &state->peak_state, v_lp); y = bw_satur_process1(&coeffs->satur_coeffs, &state->satur_state, y); y = bw_hp1_process1(&coeffs->hp1_out_coeffs, &state->hp1_out_state, y); - return bw_gain_process1(&coeffs->gain_coeffs, y); + y = bw_gain_process1(&coeffs->gain_coeffs, y); + + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT_DEEP(bw_fuzz_state_is_valid(coeffs, state)); + BW_ASSERT(bw_is_finite(y)); + + return y; } -static inline void bw_fuzz_process(bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state *BW_RESTRICT state, const float *x, float *y, size_t n_samples) { +static inline void bw_fuzz_process( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_state * BW_RESTRICT state, + const float * x, + float * y, + size_t n_samples) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT(state != NULL); + BW_ASSERT_DEEP(bw_fuzz_state_is_valid(coeffs, state)); + BW_ASSERT(x != NULL); + BW_ASSERT_DEEP(bw_has_only_finite(x, n_samples)); + BW_ASSERT(y != NULL); + bw_fuzz_update_coeffs_ctrl(coeffs); for (size_t i = 0; i < n_samples; i++) { bw_fuzz_update_coeffs_audio(coeffs); y[i] = bw_fuzz_process1(coeffs, state, x[i]); } + + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT_DEEP(bw_fuzz_state_is_valid(coeffs, state)); + BW_ASSERT_DEEP(bw_has_only_finite(y, n_samples)); } -static inline void bw_fuzz_process_multi(bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state *BW_RESTRICT const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) { +static inline void bw_fuzz_process_multi( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + bw_fuzz_state * BW_RESTRICT const * BW_RESTRICT state, + const float * const * x, + float * const * y, + size_t n_channels, + size_t n_samples) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); + BW_ASSERT(state != NULL); + BW_ASSERT(x != NULL); + BW_ASSERT(y != NULL); + bw_fuzz_update_coeffs_ctrl(coeffs); for (size_t i = 0; i < n_samples; i++) { bw_fuzz_update_coeffs_audio(coeffs); for (size_t j = 0; j < n_channels; j++) y[j][i] = bw_fuzz_process1(coeffs, state[j], x[j][i]); } + + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_reset_coeffs); } -static inline void bw_fuzz_set_fuzz(bw_fuzz_coeffs *BW_RESTRICT coeffs, float value) { +static inline void bw_fuzz_set_fuzz( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + float value) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_init); + BW_ASSERT(bw_is_finite(value)); + BW_ASSERT(value >= 0.f && value <= 1.f); + bw_peak_set_peak_gain_dB(&coeffs->peak_coeffs, 30.f * value); + + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_init); } -static inline void bw_fuzz_set_volume(bw_fuzz_coeffs *BW_RESTRICT coeffs, float value) { +static inline void bw_fuzz_set_volume( + bw_fuzz_coeffs * BW_RESTRICT coeffs, + float value) { + BW_ASSERT(coeffs != NULL); + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_init); + BW_ASSERT(bw_is_finite(value)); + BW_ASSERT(value >= 0.f && value <= 1.f); + bw_gain_set_gain_lin(&coeffs->gain_coeffs, value * value * value); + + BW_ASSERT_DEEP(bw_fuzz_coeffs_is_valid(coeffs)); + BW_ASSERT_DEEP(coeffs->state >= bw_fuzz_coeffs_state_init); +} + +static inline char bw_fuzz_coeffs_is_valid( + const bw_fuzz_coeffs * BW_RESTRICT coeffs) { + BW_ASSERT(coeffs != NULL); + +#ifdef BW_DEBUG_DEEP + if (coeffs->hash != bw_hash_sdbm("bw_fuzz_coeffs")) + return 0; + if (coeffs->state < bw_fuzz_coeffs_state_init || coeffs->state > bw_fuzz_coeffs_state_reset_coeffs) + return 0; +#endif + + return bw_hp1_coeffs_is_valid(&coeffs->hp1_in_coeffs) + && bw_svf_coeffs_is_valid(&coeffs->lp2_coeffs) + && bw_peak_coeffs_is_valid(&coeffs->peak_coeffs) + && bw_satur_coeffs_is_valid(&coeffs->satur_coeffs) + && bw_hp1_coeffs_is_valid(&coeffs->hp1_out_coeffs) + && bw_gain_coeffs_is_valid(&coeffs->gain_coeffs); +} + +static inline char bw_fuzz_state_is_valid( + const bw_fuzz_coeffs * BW_RESTRICT coeffs, + const bw_fuzz_state * BW_RESTRICT state) { + BW_ASSERT(state != NULL); + +#ifdef BW_DEBUG_DEEP + if (state->hash != bw_hash_sdbm("bw_fuzz_state")) + return 0; + + if (coeffs != NULL && coeffs->reset_id != state->coeffs_reset_id) + return 0; +#endif + + (void)coeffs; + + return bw_hp1_state_is_valid(&coeffs->hp1_in_coeffs, &state->hp1_in_state) + && bw_svf_state_is_valid(&coeffs->lp2_coeffs, &state->lp2_1_state) + && bw_svf_state_is_valid(&coeffs->lp2_coeffs, &state->lp2_2_state) + && bw_peak_state_is_valid(&coeffs->peak_coeffs, &state->peak_state) + && bw_satur_state_is_valid(&coeffs->satur_coeffs, &state->satur_state) + && bw_hp1_state_is_valid(&coeffs->hp1_out_coeffs, &state->hp1_out_state); } #ifdef __cplusplus @@ -307,19 +626,40 @@ class Fuzz { public: Fuzz(); - void setSampleRate(float sampleRate); - void reset(); + void setSampleRate( + float sampleRate); + + void reset( + float x0 = 0.f, + float * BW_RESTRICT y0 = nullptr); + + void reset( + float x0, + std::array * BW_RESTRICT y0); + + void reset( + const float * x0, + float * y0 = nullptr); + + void reset( + std::array x0, + std::array * BW_RESTRICT y0 = nullptr); + void process( - const float * const *x, - float * const *y, - size_t nSamples); + const float * const * x, + float * const * y, + size_t nSamples); + void process( std::array x, - std::array y, - size_t nSamples); + std::array y, + size_t nSamples); - void setFuzz(float value); - void setVolume(float value); + void setFuzz( + float value); + + void setVolume( + float value); /*! <<<... * } * ``` @@ -331,9 +671,9 @@ public: * change at any time in future versions. Please, do not use it directly. */ private: - bw_fuzz_coeffs coeffs; - bw_fuzz_state states[N_CHANNELS]; - bw_fuzz_state *BW_RESTRICT statesP[N_CHANNELS]; + bw_fuzz_coeffs coeffs; + bw_fuzz_state states[N_CHANNELS]; + bw_fuzz_state * BW_RESTRICT statesP[N_CHANNELS]; }; template @@ -344,40 +684,71 @@ inline Fuzz::Fuzz() { } template -inline void Fuzz::setSampleRate(float sampleRate) { +inline void Fuzz::setSampleRate( + float sampleRate) { bw_fuzz_set_sample_rate(&coeffs, sampleRate); } template -inline void Fuzz::reset() { +inline void Fuzz::reset( + float x0, + float * BW_RESTRICT y0) { bw_fuzz_reset_coeffs(&coeffs); - for (size_t i = 0; i < N_CHANNELS; i++) - bw_fuzz_reset_state(&coeffs, states + i); + if (y0 != nullptr) + for (size_t i = 0; i < N_CHANNELS; i++) + y0[i] = bw_fuzz_reset_state(&coeffs, states + i, x0); + else + for (size_t i = 0; i < N_CHANNELS; i++) + bw_fuzz_reset_state(&coeffs, states + i, x0); +} + +template +inline void Fuzz::reset( + float x0, + std::array * BW_RESTRICT y0) { + reset(x0, y0 != nullptr ? y0->data() : nullptr); +} + +template +inline void Fuzz::reset( + const float * x0, + float * y0) { + bw_fuzz_reset_coeffs(&coeffs); + bw_fuzz_reset_state_multi(&coeffs, statesP, x0, y0, N_CHANNELS); +} + +template +inline void Fuzz::reset( + std::array x0, + std::array * BW_RESTRICT y0) { + reset(x0.data(), y0 != nullptr ? y0->data() : nullptr); } template inline void Fuzz::process( - const float * const *x, - float * const *y, - size_t nSamples) { + const float * const * x, + float * const * y, + size_t nSamples) { bw_fuzz_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples); } template inline void Fuzz::process( std::array x, - std::array y, - size_t nSamples) { + std::array y, + size_t nSamples) { process(x.data(), y.data(), nSamples); } template -inline void Fuzz::setFuzz(float value) { +inline void Fuzz::setFuzz( + float value) { bw_fuzz_set_fuzz(&coeffs, value); } template -inline void Fuzz::setVolume(float value) { +inline void Fuzz::setVolume( + float value) { bw_fuzz_set_volume(&coeffs, value); }