orastron/brickworks
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 10 Wiki Activity

finalized bw_env_gen + updated synth_simple

Browse Source
This commit is contained in:
Stefano D'Angelo 2023-09-20 08:26:17 +02:00
parent cb91af4576
commit 398e051f93
3 changed files with 554 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/synth_simple/src/bw_example_synth_simple.c
View File

@ -52,7 +52,7 @@ void bw_example_synth_simple_reset(bw_example_synth_simple *instance) {
float lp, bp, hp; float lp, bp, hp;
bw_svf_reset_state(&instance->svf_coeffs, &instance->svf_state, 0.f, &lp, &bp, &hp); bw_svf_reset_state(&instance->svf_coeffs, &instance->svf_state, 0.f, &lp, &bp, &hp);
bw_env_gen_reset_coeffs(&instance->env_gen_coeffs); bw_env_gen_reset_coeffs(&instance->env_gen_coeffs);
bw_env_gen_reset_state(&instance->env_gen_coeffs, &instance->env_gen_state); bw_env_gen_reset_state(&instance->env_gen_coeffs, &instance->env_gen_state, 0);
bw_gain_reset_coeffs(&instance->gain_coeffs); bw_gain_reset_coeffs(&instance->gain_coeffs);
bw_ppm_reset_coeffs(&instance->ppm_coeffs); bw_ppm_reset_coeffs(&instance->ppm_coeffs);
bw_ppm_reset_state(&instance->ppm_coeffs, &instance->ppm_state, 0.f); bw_ppm_reset_state(&instance->ppm_coeffs, &instance->ppm_state, 0.f);

662
include/bw_env_gen.h
View File

@ -44,6 +44,12 @@
* <ul> * <ul>
* <li>Renamed <code>bw_env_gen_update_state_ctrl()</code> as * <li>Renamed <code>bw_env_gen_update_state_ctrl()</code> as
* <code>bw_env_gen_process_ctrl()</code>.</li> * <code>bw_env_gen_process_ctrl()</code>.</li>
* <li>Added <code>bw_env_gen_reset_state_multi()</code> and updated
* C++ API in this regard.</li>
* <li>Now <code>bw_env_gen_reset_state()</code> returns the initial
* output value.</li>
* <li>Added overloaded C++ <code>reset()</code> functions taking
* arrays as arguments.</li>
* <li><code>bw_env_gen_process()</code> and * <li><code>bw_env_gen_process()</code> and
* <code>bw_env_gen_process_multi()</code> now use * <code>bw_env_gen_process_multi()</code> now use
* <code>size_t</code> to count samples and channels.</li> * <code>size_t</code> to count samples and channels.</li>
@ -52,9 +58,12 @@
* <li>Moved C++ code to C header.</li> * <li>Moved C++ code to C header.</li>
* <li>Added overloaded C++ <code>process()</code> function taking * <li>Added overloaded C++ <code>process()</code> function taking
* C-style arrays as arguments.</li> * C-style arrays as arguments.</li>
* <li>Faster and more robust implementation.</li>
* <li>Removed usage of reserved identifiers.</li> * <li>Removed usage of reserved identifiers.</li>
* <li>Added pragmas to silence bogus GCC uninitialized variable * <li>Added pragmas to silence bogus GCC uninitialized variable
* warnings.</li> * warnings.</li>
* <li>Clearly specified parameter validity ranges.</li>
* <li>Added debugging code.</li>
* </ul> * </ul>
* </li> * </li>
* <li>Version <strong>0.6.0</strong>: * <li>Version <strong>0.6.0</strong>:
@ -138,57 +147,95 @@ typedef enum {
* *
* #### bw_env_gen_init() * #### bw_env_gen_init()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_init(bw_env_gen_coeffs *BW_RESTRICT coeffs); static inline void bw_env_gen_init(
bw_env_gen_coeffs * BW_RESTRICT coeffs);
/*! <<<``` /*! <<<```
* Initializes input parameter values in `coeffs`. * Initializes input parameter values in `coeffs`.
* *
* #### bw_env_gen_set_sample_rate() * #### bw_env_gen_set_sample_rate()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_set_sample_rate(bw_env_gen_coeffs *BW_RESTRICT coeffs, float sample_rate); static inline void bw_env_gen_set_sample_rate(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float sample_rate);
/*! <<<``` /*! <<<```
* Sets the `sample_rate` (Hz) value in `coeffs`. * Sets the `sample_rate` (Hz) value in `coeffs`.
* *
* #### bw_env_gen_reset_coeffs() * #### bw_env_gen_reset_coeffs()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_reset_coeffs(bw_env_gen_coeffs *BW_RESTRICT coeffs); static inline void bw_env_gen_reset_coeffs(
bw_env_gen_coeffs * BW_RESTRICT coeffs);
/*! <<<``` /*! <<<```
* Resets coefficients in `coeffs` to assume their target values. * Resets coefficients in `coeffs` to assume their target values.
* *
* #### bw_env_gen_reset_state() * #### bw_env_gen_reset_state()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_reset_state(const bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT state); static inline float bw_env_gen_reset_state(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT state,
char gate_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 gate value (`0` for off, non-`0` for on) `gate_0`.
*
* Returns the corresponding initial output value.
*
* #### bw_env_gen_reset_state_multi()
* ```>>> */
static inline void bw_env_gen_reset_state_multi(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT const * BW_RESTRICT state,
const char * BW_RESTRICT gate_0,
float * BW_RESTRICT 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 gate values (`0` for off,
* non-`0` for on) in the `gate_0` array.
*
* The corresponding initial output values are written into the `y_0` array,
* if not `NULL`.
* *
* #### bw_env_gen_update_coeffs_ctrl() * #### bw_env_gen_update_coeffs_ctrl()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_update_coeffs_ctrl(bw_env_gen_coeffs *BW_RESTRICT coeffs); static inline void bw_env_gen_update_coeffs_ctrl(
bw_env_gen_coeffs * BW_RESTRICT coeffs);
/*! <<<``` /*! <<<```
* Triggers control-rate update of coefficients in `coeffs`. * Triggers control-rate update of coefficients in `coeffs`.
* *
* #### bw_env_gen_update_coeffs_audio() * #### bw_env_gen_update_coeffs_audio()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_update_coeffs_audio(bw_env_gen_coeffs *BW_RESTRICT coeffs); static inline void bw_env_gen_update_coeffs_audio(
bw_env_gen_coeffs * BW_RESTRICT coeffs);
/*! <<<``` /*! <<<```
* Triggers audio-rate update of coefficients in `coeffs`. * Triggers audio-rate update of coefficients in `coeffs`.
* *
* #### bw_env_gen_process_ctrl() * #### bw_env_gen_process_ctrl()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_process_ctrl(const bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT state, char gate); static inline void bw_env_gen_process_ctrl(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT state,
char gate);
/*! <<<``` /*! <<<```
* Triggers control-rate update of the internal `state` using `coeffs` and * Triggers control-rate update of the internal `state` using `coeffs` and
* the given `gate` value (`0` for off, non-`0` for on). * the given `gate` value (`0` for off, non-`0` for on).
* *
* #### bw_env_gen_process1() * #### bw_env_gen_process1()
* ```>>> */ * ```>>> */
static inline float bw_env_gen_process1(const bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT state); static inline float bw_env_gen_process1(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT state);
/*! <<<``` /*! <<<```
* Generates and returns one sample using `coeffs`, while using and updating * Generates and returns one sample using `coeffs`, while using and updating
* `state` (audio rate only). * `state` (audio rate only).
* *
* #### bw_env_gen_process() * #### bw_env_gen_process()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_process(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT state, char gate, float *BW_RESTRICT y, size_t n_samples); static inline void bw_env_gen_process(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT state,
char gate,
float * BW_RESTRICT y,
size_t n_samples);
/*! <<<``` /*! <<<```
* Generates and fills the first `n_samples` of the output buffer `y` using * Generates and fills the first `n_samples` of the output buffer `y` using
* the given `gate` value (`0` for off, non-`0` for on), while using and * the given `gate` value (`0` for off, non-`0` for on), while using and
@ -198,7 +245,13 @@ static inline void bw_env_gen_process(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_
* *
* #### bw_env_gen_process_multi() * #### bw_env_gen_process_multi()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_process_multi(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT const *BW_RESTRICT state, const char *BW_RESTRICT gate, float *BW_RESTRICT const *BW_RESTRICT y, size_t n_channels, size_t n_samples); static inline void bw_env_gen_process_multi(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT const * BW_RESTRICT state,
const char * BW_RESTRICT gate,
float * BW_RESTRICT const * BW_RESTRICT y,
size_t n_channels,
size_t n_samples);
/*! <<<``` /*! <<<```
* Generates and fills the first `n_samples` of the `n_channels` output * Generates and fills the first `n_samples` of the `n_channels` output
* buffers `y` using the given `n_channels` `gate` values (`0` for off, * buffers `y` using the given `n_channels` `gate` values (`0` for off,
@ -209,53 +262,93 @@ static inline void bw_env_gen_process_multi(bw_env_gen_coeffs *BW_RESTRICT coeff
* *
* #### bw_env_gen_set_attack() * #### bw_env_gen_set_attack()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_set_attack(bw_env_gen_coeffs *BW_RESTRICT coeffs, float value); static inline void bw_env_gen_set_attack(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float value);
/*! <<<``` /*! <<<```
* Sets the attack time to `value` (s) in `coeffs`. * Sets the attack time to `value` (s) in `coeffs`.
* *
* `value` must be smaller than `1e9f`. * Valid range: [`0.f`, `60.f`].
* *
* Default value: `0.f`. * Default value: `0.f`.
* *
* #### bw_env_gen_set_decay() * #### bw_env_gen_set_decay()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_set_decay(bw_env_gen_coeffs *BW_RESTRICT coeffs, float value); static inline void bw_env_gen_set_decay(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float value);
/*! <<<``` /*! <<<```
* Sets the decay time to `value` (s) in `coeffs`. * Sets the decay time to `value` (s) in `coeffs`.
* *
* `value` must be smaller than `1e9f`. * Valid range: [`0.f`, `60.f`].
* *
* Default value: `0.f`. * Default value: `0.f`.
* *
* #### bw_env_gen_set_sustain() * #### bw_env_gen_set_sustain()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_set_sustain(bw_env_gen_coeffs *BW_RESTRICT coeffs, float value); static inline void bw_env_gen_set_sustain(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float value);
/*! <<<``` /*! <<<```
* Sets the sustain level to `value` in `coeffs`. * Sets the sustain level to `value` in `coeffs`.
* *
* Valid range: [`0.f`, `1.f`].
*
* Default value: `1.f`. * Default value: `1.f`.
* *
* #### bw_env_gen_set_release() * #### bw_env_gen_set_release()
* ```>>> */ * ```>>> */
static inline void bw_env_gen_set_release(bw_env_gen_coeffs *BW_RESTRICT coeffs, float value); static inline void bw_env_gen_set_release(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float value);
/*! <<<``` /*! <<<```
* Sets the release time to `value` (s) in `coeffs`. * Sets the release time to `value` (s) in `coeffs`.
* *
* `value` must be smaller than `1e9f`. * Valid range: [`0.f`, `60.f`].
* *
* Default value: `0.f`. * Default value: `0.f`.
* *
* #### bw_env_gen_get_phase() * #### bw_env_gen_get_phase()
* ```>>> */ * ```>>> */
static inline bw_env_gen_phase bw_env_gen_get_phase(const bw_env_gen_state *BW_RESTRICT state); static inline bw_env_gen_phase bw_env_gen_get_phase(
const bw_env_gen_state * BW_RESTRICT state);
/*! <<<``` /*! <<<```
* Returns the current envelope generator phase as stored in `state`. * Returns the current envelope generator phase as stored in `state`.
* *
* #### bw_env_gen_get_y_z1() * #### bw_env_gen_get_y_z1()
* ```>>> */ * ```>>> */
static inline float bw_env_gen_get_y_z1(const bw_env_gen_state *BW_RESTRICT state); static inline float bw_env_gen_get_y_z1(
const bw_env_gen_state * BW_RESTRICT state);
/*! <<<``` /*! <<<```
* Returns the last output sample as stored in `state`. * Returns the last output sample as stored in `state`.
*
* #### bw_env_gen_coeffs_is_valid()
* ```>>> */
static inline char bw_env_gen_coeffs_is_valid(
const bw_env_gen_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_env_gen_coeffs`.
*
* #### bw_env_gen_state_is_valid()
* ```>>> */
static inline char bw_env_gen_state_is_valid(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
const bw_env_gen_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_env_gen_state`.
* }}} */ * }}} */
#ifdef __cplusplus #ifdef __cplusplus
@ -274,28 +367,49 @@ static inline float bw_env_gen_get_y_z1(const bw_env_gen_state *BW_RESTRICT stat
extern "C" { extern "C" {
#endif #endif
#ifdef BW_DEBUG_DEEP
enum bw_env_gen_coeffs_state {
bw_env_gen_coeffs_state_invalid,
bw_env_gen_coeffs_state_init,
bw_env_gen_coeffs_state_set_sample_rate,
bw_env_gen_coeffs_state_reset_coeffs
};
#endif
struct bw_env_gen_coeffs { struct bw_env_gen_coeffs {
#ifdef BW_DEBUG_DEEP
uint32_t hash;
enum bw_env_gen_coeffs_state state;
uint32_t reset_id;
#endif
// Sub-components // Sub-components
bw_one_pole_coeffs smooth_coeffs; bw_one_pole_coeffs smooth_coeffs;
// Coefficients // Coefficients
float T; float k_T;
float attack_inc; uint32_t attack_inc;
float decay_inc; uint32_t decay_dec;
float release_inc; uint32_t sustain_v;
uint32_t release_dec;
// Parameters // Parameters
float attack; float attack;
float decay; float decay;
float sustain; float sustain;
float release; float release;
int param_changed; int param_changed;
}; };
struct bw_env_gen_state { struct bw_env_gen_state {
#ifdef BW_DEBUG_DEEP
uint32_t hash;
uint32_t coeffs_reset_id;
#endif
bw_env_gen_phase phase; bw_env_gen_phase phase;
float y_z1; uint32_t v;
bw_one_pole_state smooth_state; bw_one_pole_state smooth_state;
}; };
@ -304,49 +418,161 @@ struct bw_env_gen_state {
#define BW_ENV_GEN_PARAM_SUSTAIN (1<<2) #define BW_ENV_GEN_PARAM_SUSTAIN (1<<2)
#define BW_ENV_GEN_PARAM_RELEASE (1<<3) #define BW_ENV_GEN_PARAM_RELEASE (1<<3)
static inline void bw_env_gen_init(bw_env_gen_coeffs *BW_RESTRICT coeffs) { #define BW_ENV_V_MAX 4294967040
static inline void bw_env_gen_init(
bw_env_gen_coeffs * BW_RESTRICT coeffs) {
BW_ASSERT(coeffs != NULL);
bw_one_pole_init(&coeffs->smooth_coeffs); bw_one_pole_init(&coeffs->smooth_coeffs);
bw_one_pole_set_tau(&coeffs->smooth_coeffs, 0.05f); bw_one_pole_set_tau(&coeffs->smooth_coeffs, 0.05f);
coeffs->attack = 0.f; coeffs->attack = 0.f;
coeffs->decay = 0.f; coeffs->decay = 0.f;
coeffs->sustain = 1.f; coeffs->sustain = 1.f;
coeffs->release = 0.f; coeffs->release = 0.f;
#ifdef BW_DEBUG_DEEP
coeffs->hash = bw_hash_sdbm("bw_env_gen_coeffs");
coeffs->state = bw_env_gen_coeffs_state_init;
coeffs->reset_id = coeffs->hash + 1;
#endif
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state == bw_env_gen_coeffs_state_init);
} }
static inline void bw_env_gen_set_sample_rate(bw_env_gen_coeffs *BW_RESTRICT coeffs, float sample_rate) { static inline void bw_env_gen_set_sample_rate(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float sample_rate) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
BW_ASSERT(bw_is_finite(sample_rate) && sample_rate > 0.f);
bw_one_pole_set_sample_rate(&coeffs->smooth_coeffs, sample_rate); bw_one_pole_set_sample_rate(&coeffs->smooth_coeffs, sample_rate);
bw_one_pole_reset_coeffs(&coeffs->smooth_coeffs); bw_one_pole_reset_coeffs(&coeffs->smooth_coeffs);
coeffs->T = 1.f / sample_rate; coeffs->k_T = (float)BW_ENV_V_MAX / sample_rate;
#ifdef BW_DEBUG_DEEP
coeffs->state = bw_env_gen_coeffs_state_set_sample_rate;
#endif
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state == bw_env_gen_coeffs_state_set_sample_rate);
} }
static inline void bw_env_gen_reset_coeffs(bw_env_gen_coeffs *BW_RESTRICT coeffs) { static inline void bw_env_gen_do_update_coeffs_ctrl(
coeffs->param_changed = ~0; bw_env_gen_coeffs * BW_RESTRICT coeffs) {
bw_env_gen_update_coeffs_ctrl(coeffs);
}
static inline void bw_env_gen_reset_state(const bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT state) {
(void)coeffs;
state->phase = bw_env_gen_phase_off;
state->y_z1 = 0.f;
}
static inline void bw_env_gen_update_coeffs_ctrl(bw_env_gen_coeffs *BW_RESTRICT coeffs) {
if (coeffs->param_changed) { if (coeffs->param_changed) {
// 1 ns considered instantaneous // 1 ns considered instantaneous
if (coeffs->param_changed & BW_ENV_GEN_PARAM_ATTACK) if (coeffs->param_changed & BW_ENV_GEN_PARAM_ATTACK)
coeffs->attack_inc = coeffs->attack > 1e-9f ? coeffs->T * bw_rcpf(coeffs->attack) : INFINITY; coeffs->attack_inc = coeffs->attack > 1e-9f ? coeffs->k_T * bw_rcpf(coeffs->attack) : UINT32_MAX;
if (coeffs->param_changed & (BW_ENV_GEN_PARAM_DECAY | BW_ENV_GEN_PARAM_SUSTAIN)) if (coeffs->param_changed & (BW_ENV_GEN_PARAM_DECAY | BW_ENV_GEN_PARAM_SUSTAIN))
coeffs->decay_inc = coeffs->decay > 1e-9f ? (coeffs->sustain - 1.f) * coeffs->T * bw_rcpf(coeffs->decay) : -INFINITY; coeffs->decay_dec = coeffs->decay > 1e-9f ? (1.f - coeffs->sustain) * (coeffs->k_T * bw_rcpf(coeffs->decay)) : UINT32_MAX;
if (coeffs->param_changed & BW_ENV_GEN_PARAM_SUSTAIN)
coeffs->sustain_v = (uint32_t)((float)BW_ENV_V_MAX * coeffs->sustain);
if (coeffs->param_changed & (BW_ENV_GEN_PARAM_SUSTAIN | BW_ENV_GEN_PARAM_RELEASE)) if (coeffs->param_changed & (BW_ENV_GEN_PARAM_SUSTAIN | BW_ENV_GEN_PARAM_RELEASE))
coeffs->release_inc = coeffs->release > 1e-9f ? -coeffs->sustain * coeffs->T * bw_rcpf(coeffs->release) : -INFINITY; coeffs->release_dec = coeffs->release > 1e-9f ? coeffs->sustain * (coeffs->k_T * bw_rcpf(coeffs->release)) : UINT32_MAX;
coeffs->param_changed = 0;
} }
} }
static inline void bw_env_gen_update_coeffs_audio(bw_env_gen_coeffs *BW_RESTRICT coeffs) { static inline void bw_env_gen_reset_coeffs(
bw_env_gen_coeffs * BW_RESTRICT coeffs) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_set_sample_rate);
coeffs->param_changed = ~0;
bw_env_gen_do_update_coeffs_ctrl(coeffs);
#ifdef BW_DEBUG_DEEP
coeffs->state = bw_env_gen_coeffs_state_reset_coeffs;
coeffs->reset_id++;
#endif
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state == bw_env_gen_coeffs_state_reset_coeffs);
}
static inline float bw_env_gen_reset_state(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT state,
char gate) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT(state != NULL);
bw_one_pole_reset_state(&coeffs->smooth_coeffs, &state->smooth_state, coeffs->sustain);
state->phase = bw_env_gen_phase_off;
state->v = gate ? coeffs->sustain_v : 0;
const float y = (1.f / (float)BW_ENV_V_MAX) * state->v;
#ifdef BW_DEBUG_DEEP
state->hash = bw_hash_sdbm("bw_env_gen_state");
state->coeffs_reset_id = coeffs->reset_id;
#endif
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(coeffs, state));
BW_ASSERT(bw_is_finite(y));
return y;
}
static inline void bw_env_gen_reset_state_multi(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT const * BW_RESTRICT state,
const char * BW_RESTRICT gate_0,
float * BW_RESTRICT y_0,
size_t n_channels) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT(state != NULL);
BW_ASSERT(gate_0 != NULL);
if (y_0 != NULL)
for (size_t i = 0; i < n_channels; i++)
y_0[i] = bw_env_gen_reset_state(coeffs, state[i], gate_0[i]);
else
for (size_t i = 0; i < n_channels; i++)
bw_env_gen_reset_state(coeffs, state[i], gate_0[i]);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT_DEEP(y_0 != NULL ? bw_has_only_finite(y_0, n_channels) : 1);
}
static inline void bw_env_gen_update_coeffs_ctrl(
bw_env_gen_coeffs * BW_RESTRICT coeffs) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
bw_env_gen_do_update_coeffs_ctrl(coeffs);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
}
static inline void bw_env_gen_update_coeffs_audio(
bw_env_gen_coeffs * BW_RESTRICT coeffs) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
(void)coeffs; (void)coeffs;
} }
static inline void bw_env_gen_process_ctrl(const bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT state, char gate) { static inline void bw_env_gen_process_ctrl(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT state,
char gate) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT(state != NULL);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(coeffs, state));
(void)coeffs; (void)coeffs;
if (gate) { if (gate) {
if (state->phase == bw_env_gen_phase_off || state->phase == bw_env_gen_phase_release) if (state->phase == bw_env_gen_phase_off || state->phase == bw_env_gen_phase_release)
@ -355,45 +581,75 @@ static inline void bw_env_gen_process_ctrl(const bw_env_gen_coeffs *BW_RESTRICT
if (state->phase != bw_env_gen_phase_off) if (state->phase != bw_env_gen_phase_off)
state->phase = bw_env_gen_phase_release; state->phase = bw_env_gen_phase_release;
} }
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(coeffs, state));
} }
static inline float bw_env_gen_process1(const bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT state) { static inline float bw_env_gen_process1(
float v = 0.f; const bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT state) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT(state != NULL);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(coeffs, state));
uint32_t v = 0;
switch (state->phase) { switch (state->phase) {
case bw_env_gen_phase_attack: case bw_env_gen_phase_attack:
v = state->y_z1 + coeffs->attack_inc; v = state->v + coeffs->attack_inc;
if (v >= 1.f) { if (v == BW_ENV_V_MAX || v <= state->v) {
v = 1.f; v = BW_ENV_V_MAX;
state->phase = bw_env_gen_phase_decay; state->phase = bw_env_gen_phase_decay;
} }
break; break;
case bw_env_gen_phase_decay: case bw_env_gen_phase_decay:
v = state->y_z1 + coeffs->decay_inc; v = state->v - coeffs->decay_dec;
if (v <= coeffs->sustain) { if (v <= coeffs->sustain_v || v >= state->v) {
v = coeffs->sustain; v = coeffs->sustain_v;
state->phase = bw_env_gen_phase_sustain; state->phase = bw_env_gen_phase_sustain;
bw_one_pole_reset_state(&coeffs->smooth_coeffs, &state->smooth_state, coeffs->sustain); bw_one_pole_reset_state(&coeffs->smooth_coeffs, &state->smooth_state, coeffs->sustain);
} }
break; break;
case bw_env_gen_phase_sustain: case bw_env_gen_phase_sustain:
v = bw_one_pole_process1(&coeffs->smooth_coeffs, &state->smooth_state, coeffs->sustain); v = (uint32_t)((float)BW_ENV_V_MAX * bw_one_pole_process1(&coeffs->smooth_coeffs, &state->smooth_state, coeffs->sustain));
break; break;
case bw_env_gen_phase_release: case bw_env_gen_phase_release:
v = state->y_z1 + coeffs->release_inc; v = state->v - coeffs->release_dec;
if (v <= 0.f) { if (v == 0 || v >= state->v) {
v = 0.f; v = 0;
state->phase = bw_env_gen_phase_off; state->phase = bw_env_gen_phase_off;
} }
break; break;
case bw_env_gen_phase_off: case bw_env_gen_phase_off:
v = 0.f; v = 0;
break; break;
} }
state->y_z1 = v; state->v = v;
return v; const float y = (1.f / (float)BW_ENV_V_MAX) * v;
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(coeffs, state));
BW_ASSERT(bw_is_finite(y));
return y;
} }
static inline void bw_env_gen_process(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT state, char gate, float *BW_RESTRICT y, size_t n_samples) { static inline void bw_env_gen_process(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT state,
char gate,
float * BW_RESTRICT y,
size_t n_samples) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT(state != NULL);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(coeffs, state));
bw_env_gen_update_coeffs_ctrl(coeffs); bw_env_gen_update_coeffs_ctrl(coeffs);
bw_env_gen_process_ctrl(coeffs, state, gate); bw_env_gen_process_ctrl(coeffs, state, gate);
if (y != NULL) if (y != NULL)
@ -402,9 +658,26 @@ static inline void bw_env_gen_process(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_
else else
for (size_t i = 0; i < n_samples; i++) for (size_t i = 0; i < n_samples; i++)
bw_env_gen_process1(coeffs, state); bw_env_gen_process1(coeffs, state);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(coeffs, state));
BW_ASSERT_DEEP(y != NULL ? bw_has_only_finite(y, n_samples) : 1);
} }
static inline void bw_env_gen_process_multi(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state *BW_RESTRICT const *BW_RESTRICT state, const char *BW_RESTRICT gate, float *BW_RESTRICT const *BW_RESTRICT y, size_t n_channels, size_t n_samples) { static inline void bw_env_gen_process_multi(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
bw_env_gen_state * BW_RESTRICT const * BW_RESTRICT state,
const char * BW_RESTRICT gate,
float * BW_RESTRICT const * BW_RESTRICT y,
size_t n_channels,
size_t n_samples) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
BW_ASSERT(state != NULL);
BW_ASSERT(gate != NULL);
bw_env_gen_update_coeffs_ctrl(coeffs); bw_env_gen_update_coeffs_ctrl(coeffs);
for (size_t j = 0; j < n_channels; j++) for (size_t j = 0; j < n_channels; j++)
bw_env_gen_process_ctrl(coeffs, state[j], gate[j]); bw_env_gen_process_ctrl(coeffs, state[j], gate[j]);
@ -419,9 +692,20 @@ static inline void bw_env_gen_process_multi(bw_env_gen_coeffs *BW_RESTRICT coeff
for (size_t i = 0; i < n_samples; i++) for (size_t i = 0; i < n_samples; i++)
for (size_t j = 0; j < n_channels; j++) for (size_t j = 0; j < n_channels; j++)
bw_env_gen_process1(coeffs, state[j]); bw_env_gen_process1(coeffs, state[j]);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_reset_coeffs);
} }
static inline void bw_env_gen_set_attack(bw_env_gen_coeffs *BW_RESTRICT coeffs, float value) { static inline void bw_env_gen_set_attack(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float value) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
BW_ASSERT(bw_is_finite(value));
BW_ASSERT(value >= 0.f && value <= 60.f);
if (coeffs->attack != value) { if (coeffs->attack != value) {
coeffs->attack = value; coeffs->attack = value;
#pragma GCC diagnostic push #pragma GCC diagnostic push
@ -429,9 +713,20 @@ static inline void bw_env_gen_set_attack(bw_env_gen_coeffs *BW_RESTRICT coeffs,
coeffs->param_changed |= BW_ENV_GEN_PARAM_ATTACK; coeffs->param_changed |= BW_ENV_GEN_PARAM_ATTACK;
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
} }
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
} }
static inline void bw_env_gen_set_decay(bw_env_gen_coeffs *BW_RESTRICT coeffs, float value) { static inline void bw_env_gen_set_decay(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float value) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
BW_ASSERT(bw_is_finite(value));
BW_ASSERT(value >= 0.f && value <= 60.f);
if (coeffs->decay != value) { if (coeffs->decay != value) {
coeffs->decay = value; coeffs->decay = value;
#pragma GCC diagnostic push #pragma GCC diagnostic push
@ -439,9 +734,20 @@ static inline void bw_env_gen_set_decay(bw_env_gen_coeffs *BW_RESTRICT coeffs, f
coeffs->param_changed |= BW_ENV_GEN_PARAM_DECAY; coeffs->param_changed |= BW_ENV_GEN_PARAM_DECAY;
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
} }
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
} }
static inline void bw_env_gen_set_sustain(bw_env_gen_coeffs *BW_RESTRICT coeffs, float value) { static inline void bw_env_gen_set_sustain(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float value) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
BW_ASSERT(bw_is_finite(value));
BW_ASSERT(value >= 0.f && value <= 1.f);
if (coeffs->sustain != value) { if (coeffs->sustain != value) {
coeffs->sustain = value; coeffs->sustain = value;
#pragma GCC diagnostic push #pragma GCC diagnostic push
@ -449,9 +755,20 @@ static inline void bw_env_gen_set_sustain(bw_env_gen_coeffs *BW_RESTRICT coeffs,
coeffs->param_changed |= BW_ENV_GEN_PARAM_SUSTAIN; coeffs->param_changed |= BW_ENV_GEN_PARAM_SUSTAIN;
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
} }
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
} }
static inline void bw_env_gen_set_release(bw_env_gen_coeffs *BW_RESTRICT coeffs, float value) { static inline void bw_env_gen_set_release(
bw_env_gen_coeffs * BW_RESTRICT coeffs,
float value) {
BW_ASSERT(coeffs != NULL);
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
BW_ASSERT(bw_is_finite(value));
BW_ASSERT(value >= 0.f && value <= 60.f);
if (coeffs->release != value) { if (coeffs->release != value) {
coeffs->release = value; coeffs->release = value;
#pragma GCC diagnostic push #pragma GCC diagnostic push
@ -459,14 +776,74 @@ static inline void bw_env_gen_set_release(bw_env_gen_coeffs *BW_RESTRICT coeffs,
coeffs->param_changed |= BW_ENV_GEN_PARAM_RELEASE; coeffs->param_changed |= BW_ENV_GEN_PARAM_RELEASE;
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
} }
BW_ASSERT_DEEP(bw_env_gen_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_env_gen_coeffs_state_init);
} }
static inline bw_env_gen_phase bw_env_gen_get_phase(const bw_env_gen_state *BW_RESTRICT state) { static inline bw_env_gen_phase bw_env_gen_get_phase(
const bw_env_gen_state * BW_RESTRICT state) {
BW_ASSERT(state != NULL);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(NULL, state));
return state->phase; return state->phase;
} }
static inline float bw_env_gen_get_y_z1(const bw_env_gen_state *BW_RESTRICT state) { static inline float bw_env_gen_get_y_z1(
return state->y_z1; const bw_env_gen_state * BW_RESTRICT state) {
BW_ASSERT(state != NULL);
BW_ASSERT_DEEP(bw_env_gen_state_is_valid(NULL, state));
const float y = (1.f / (float)BW_ENV_V_MAX) * state->v;
BW_ASSERT(bw_is_finite(y));
return y;
}
static inline char bw_env_gen_coeffs_is_valid(
const bw_env_gen_coeffs * BW_RESTRICT coeffs) {
BW_ASSERT(coeffs != NULL);
#ifdef BW_DEBUG_DEEP
if (coeffs->hash != bw_hash_sdbm("bw_env_gen_coeffs"))
return 0;
if (coeffs->state < bw_env_gen_coeffs_state_init || coeffs->state > bw_env_gen_coeffs_state_reset_coeffs)
return 0;
#endif
if (!bw_is_finite(coeffs->attack) || coeffs->attack < 0.f || coeffs->attack > 60.f)
return 0;
if (!bw_is_finite(coeffs->decay) || coeffs->decay < 0.f || coeffs->decay > 60.f)
return 0;
if (!bw_is_finite(coeffs->sustain) || coeffs->sustain < 0.f || coeffs->sustain > 1.f)
return 0;
if (!bw_is_finite(coeffs->release) || coeffs->release < 0.f || coeffs->release > 60.f)
return 0;
#ifdef BW_DEBUG_DEEP
if (coeffs->state >= bw_env_gen_coeffs_state_set_sample_rate && coeffs->k_T <= 0.f)
return 0.f;
#endif
return bw_one_pole_coeffs_is_valid(&coeffs->smooth_coeffs);
}
static inline char bw_env_gen_state_is_valid(
const bw_env_gen_coeffs * BW_RESTRICT coeffs,
const bw_env_gen_state * BW_RESTRICT state) {
BW_ASSERT(state != NULL);
#ifdef BW_DEBUG_DEEP
if (state->hash != bw_hash_sdbm("bw_env_gen_state"))
return 0;
if (coeffs != NULL && coeffs->reset_id != state->coeffs_reset_id)
return 0;
#endif
return state->phase >= bw_env_gen_phase_off && state->phase <= bw_env_gen_phase_release
&& bw_one_pole_state_is_valid(coeffs ? &coeffs->smooth_coeffs : NULL, &state->smooth_state);
} }
#undef BW_ENV_GEN_PARAM_ATTACK #undef BW_ENV_GEN_PARAM_ATTACK
@ -474,6 +851,8 @@ static inline float bw_env_gen_get_y_z1(const bw_env_gen_state *BW_RESTRICT stat
#undef BW_ENV_GEN_PARAM_SUSTAIN #undef BW_ENV_GEN_PARAM_SUSTAIN
#undef BW_ENV_GEN_PARAM_RELEASE #undef BW_ENV_GEN_PARAM_RELEASE
#undef BW_ENV_V_MAX
#ifdef __cplusplus #ifdef __cplusplus
} }
@ -491,24 +870,52 @@ class EnvGen {
public: public:
EnvGen(); EnvGen();
void setSampleRate(float sampleRate); void setSampleRate(
void reset(); float sampleRate);
void process(
const char *BW_RESTRICT gate,
float *BW_RESTRICT const *BW_RESTRICT y,
size_t nSamples);
void process(
std::array<char, N_CHANNELS> gate,
std::array<float *BW_RESTRICT, N_CHANNELS> y,
size_t nSamples);
void setAttack(float value); void reset(
void setDecay(float value); char gate0 = 0,
void setSustain(float value); float * BW_RESTRICT y0 = nullptr);
void setRelease(float value);
void reset(
char gate0,
std::array<float, N_CHANNELS> * BW_RESTRICT y0);
void reset(
const char * BW_RESTRICT gate0,
float * BW_RESTRICT y0 = nullptr);
void reset(
std::array<char, N_CHANNELS> gate0,
std::array<float, N_CHANNELS> * BW_RESTRICT y0 = nullptr);
void process(
const char * BW_RESTRICT gate,
float * BW_RESTRICT const * BW_RESTRICT y,
size_t nSamples);
void process(
std::array<char, N_CHANNELS> gate,
std::array<float * BW_RESTRICT, N_CHANNELS> y,
size_t nSamples);
void setAttack(
float value);
void setDecay(
float value);
void setSustain(
float value);
void setRelease(
float value);
bw_env_gen_phase getPhase(size_t channel); bw_env_gen_phase getPhase(
float getYZ1(size_t channel); size_t channel);
float getYZ1(
size_t channel);
/*! <<<... /*! <<<...
* } * }
* ``` * ```
@ -520,9 +927,9 @@ public:
* change at any time in future versions. Please, do not use it directly. */ * change at any time in future versions. Please, do not use it directly. */
private: private:
bw_env_gen_coeffs coeffs; bw_env_gen_coeffs coeffs;
bw_env_gen_state states[N_CHANNELS]; bw_env_gen_state states[N_CHANNELS];
bw_env_gen_state *BW_RESTRICT statesP[N_CHANNELS]; bw_env_gen_state * BW_RESTRICT statesP[N_CHANNELS];
}; };
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
@ -533,60 +940,95 @@ inline EnvGen<N_CHANNELS>::EnvGen() {
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::setSampleRate(float sampleRate) { inline void EnvGen<N_CHANNELS>::setSampleRate(
float sampleRate) {
bw_env_gen_set_sample_rate(&coeffs, sampleRate); bw_env_gen_set_sample_rate(&coeffs, sampleRate);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::reset() { inline void EnvGen<N_CHANNELS>::reset(
char gate0,
float * BW_RESTRICT y0) {
bw_env_gen_reset_coeffs(&coeffs); bw_env_gen_reset_coeffs(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++) if (y0 != nullptr)
bw_env_gen_reset_state(&coeffs, states + i); for (size_t i = 0; i < N_CHANNELS; i++)
y0[i] = bw_env_gen_reset_state(&coeffs, states + i, gate0);
else
for (size_t i = 0; i < N_CHANNELS; i++)
bw_env_gen_reset_state(&coeffs, states + i, gate0);
}
template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::reset(
char gate0,
std::array<float, N_CHANNELS> * BW_RESTRICT y0) {
reset(gate0, y0 != nullptr ? y0->data() : nullptr);
}
template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::reset(
const char * BW_RESTRICT gate0,
float * BW_RESTRICT y0) {
bw_env_gen_reset_coeffs(&coeffs);
bw_env_gen_reset_state_multi(&coeffs, statesP, gate0, y0, N_CHANNELS);
}
template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::reset(
std::array<char, N_CHANNELS> gate0,
std::array<float, N_CHANNELS> * BW_RESTRICT y0) {
reset(gate0.data(), y0 != nullptr ? y0->data() : nullptr);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::process( inline void EnvGen<N_CHANNELS>::process(
const char *BW_RESTRICT gate, const char * BW_RESTRICT gate,
float *BW_RESTRICT const *BW_RESTRICT y, float * BW_RESTRICT const * BW_RESTRICT y,
size_t nSamples) { size_t nSamples) {
bw_env_gen_process_multi(&coeffs, statesP, gate, y, N_CHANNELS, nSamples); bw_env_gen_process_multi(&coeffs, statesP, gate, y, N_CHANNELS, nSamples);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::process( inline void EnvGen<N_CHANNELS>::process(
std::array<char, N_CHANNELS> gate, std::array<char, N_CHANNELS> gate,
std::array<float *BW_RESTRICT, N_CHANNELS> y, std::array<float * BW_RESTRICT, N_CHANNELS> y,
size_t nSamples) { size_t nSamples) {
process(gate.data(), y.data(), nSamples); process(gate.data(), y.data(), nSamples);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::setAttack(float value) { inline void EnvGen<N_CHANNELS>::setAttack(
float value) {
bw_env_gen_set_attack(&coeffs, value); bw_env_gen_set_attack(&coeffs, value);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::setDecay(float value) { inline void EnvGen<N_CHANNELS>::setDecay(
float value) {
bw_env_gen_set_decay(&coeffs, value); bw_env_gen_set_decay(&coeffs, value);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::setSustain(float value) { inline void EnvGen<N_CHANNELS>::setSustain(
float value) {
bw_env_gen_set_sustain(&coeffs, value); bw_env_gen_set_sustain(&coeffs, value);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::setRelease(float value) { inline void EnvGen<N_CHANNELS>::setRelease(
float value) {
bw_env_gen_set_release(&coeffs, value); bw_env_gen_set_release(&coeffs, value);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline bw_env_gen_phase EnvGen<N_CHANNELS>::getPhase(size_t channel) { inline bw_env_gen_phase EnvGen<N_CHANNELS>::getPhase(
size_t channel) {
return bw_env_gen_get_phase(states + channel); return bw_env_gen_get_phase(states + channel);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline float EnvGen<N_CHANNELS>::getYZ1(size_t channel) { inline float EnvGen<N_CHANNELS>::getYZ1(
size_t channel) {
return bw_env_gen_get_y_z1(states + channel); return bw_env_gen_get_y_z1(states + channel);
} }

2
include/bw_trem.h
View File

@ -222,7 +222,7 @@ static inline void bw_trem_set_amount(
* *
* Default value: `1.f`. * Default value: `1.f`.
* *
* #### bw_trem_coeffs_is_valid() * #### bw_trem_coeffs_is_valid()
* ```>>> */ * ```>>> */
static inline char bw_trem_coeffs_is_valid( static inline char bw_trem_coeffs_is_valid(
const bw_trem_coeffs * BW_RESTRICT coeffs); const bw_trem_coeffs * BW_RESTRICT coeffs);