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

added const everywhere + fixed bw_buf + fixed c++ api in bw_src +

Browse Source 
improved bw_src + using new buf api in synthpp_poly
This commit is contained in:
Stefano D'Angelo 2023-08-13 15:37:15 +02:00
parent 61c2b48817
commit ec1a70835c
52 changed files with 296 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
TODO
View File

@ -36,7 +36,7 @@ code:
* better src filter
* bw_env_gen process_multi gate const?
* c++ get coeffs/state? or public? src nIn/OutSamples case (array vs single value), delay read/write, process1? process single?
* check unititialized warnings (check fxpp_comp in particular)
* check unititialized warnings (check fxpp_comp in particular vs fxpp_satur)
* clearly specify that state is tied to a particular set of coeffs (1:N)
* modulation vs process (multi) no update (post 1.0.0)???
* check assumptions w.r.t. usage of math functions

94
examples/synthpp_poly/src/bw_example_synthpp_poly.cpp
View File

@ -167,28 +167,16 @@ void bw_example_synthpp_poly_process(bw_example_synthpp_poly *instance, const fl
const float vcf_mod_k = 0.3f * instance->params[p_vcf_mod];
float *xb0[N_VOICES], *xb1[N_VOICES], *xb2[N_VOICES], *xb3[N_VOICES], *xb4[N_VOICES];
std::array<float *, N_VOICES> b0, b1, b2, b3, b4, na;
std::array<const float *, N_VOICES> cb0, cb1, cb2, cb3, cb4;
std::array<char, N_VOICES> gates;
float *b0[N_VOICES], *b1[N_VOICES], *b2[N_VOICES], *b3[N_VOICES], *b4[N_VOICES], *na[N_VOICES];
char xgates[N_VOICES];
for (int j = 0; j < N_VOICES; j++) {
xb0[j] = instance->voices[j].buf[0];
xb1[j] = instance->voices[j].buf[1];
xb2[j] = instance->voices[j].buf[2];
xb3[j] = instance->voices[j].buf[3];
xb4[j] = instance->voices[j].buf[4];
b0.data()[j] = instance->voices[j].buf[0];
b1.data()[j] = instance->voices[j].buf[1];
b2.data()[j] = instance->voices[j].buf[2];
b3.data()[j] = instance->voices[j].buf[3];
b4.data()[j] = instance->voices[j].buf[4];
na.data()[j] = nullptr;
cb0.data()[j] = instance->voices[j].buf[0];
cb1.data()[j] = instance->voices[j].buf[1];
cb2.data()[j] = instance->voices[j].buf[2];
cb3.data()[j] = instance->voices[j].buf[3];
cb4.data()[j] = instance->voices[j].buf[4];
gates.data()[j] = instance->voices[j].gate;
b0[j] = instance->voices[j].buf[0];
b1[j] = instance->voices[j].buf[1];
b2[j] = instance->voices[j].buf[2];
b3[j] = instance->voices[j].buf[3];
b4[j] = instance->voices[j].buf[4];
na[j] = nullptr;
xgates[j] = instance->voices[j].gate;
}
for (int i = 0; i < n_samples; i += BUFFER_SIZE) {
@ -196,81 +184,81 @@ void bw_example_synthpp_poly_process(bw_example_synthpp_poly *instance, const fl
int n = bw_minf(n_samples - i, BUFFER_SIZE);
for (int j = 0; j < N_VOICES; j++)
instance->voices[j].vco3PhaseGen.process({nullptr}, {b0.data()[j]}, {b1.data()[j]}, n);
instance->voices[j].vco3PhaseGen.process({nullptr}, {b0[j]}, {b1[j]}, n);
if (instance->params[p_vco3_waveform] >= (1.f / 4.f + 1.f / 2.f)) {
instance->vco3OscTri.process(cb0, cb1, b0, n);
instance->vco3OscTri.process(b0, b1, b0, n);
instance->vco3OscPulse.reset();
} else if (instance->params[p_vco3_waveform] >= (1.f / 4.f)) {
instance->vco3OscPulse.process(cb0, cb1, b0, n);
instance->vco3OscPulse.process(b0, b1, b0, n);
instance->vco3OscTri.reset();
} else {
instance->vco3OscSaw.process(cb0, cb1, b0, n);
instance->vco3OscSaw.process(b0, b1, b0, n);
instance->vco3OscPulse.reset();
instance->vco3OscTri.reset();
}
instance->noiseGen.process(b1, n);
if (instance->params[p_noise_color] >= 0.5f)
instance->pinkFilt.process(cb1, b1, n);
instance->pinkFilt.process(b1, b1, n);
else
instance->pinkFilt.reset(); // FIXME: calling this here is sloppy coding
bufScale<N_VOICES>(xb1, 5.f, xb1, n);
bufScale<N_VOICES>(b1, 5.f, b1, n);
float vcf_mod[N_VOICES];
for (int j = 0; j < N_VOICES; j++) {
for (int k = 0; k < n; k++)
b2.data()[j][k] = instance->mod_wheel * (b0.data()[j][k] + instance->params[p_mod_mix] * (b1.data()[j][k] - b0.data()[j][k]));
vcf_mod[j] = vcf_mod_k * b2.data()[j][0];
b2[j][k] = instance->mod_wheel * (b0[j][k] + instance->params[p_mod_mix] * (b1[j][k] - b0[j][k]));
vcf_mod[j] = vcf_mod_k * b2[j][0];
}
for (int j = 0; j < N_VOICES; j++) {
bufScale<1>({xb2[j]}, instance->params[p_vco1_mod], {xb3[j]}, n);
instance->voices[j].vco1PhaseGen.process({b3.data()[j]}, {b4.data()[j]}, {b3.data()[j]}, n);
bufScale<1>({b2[j]}, instance->params[p_vco1_mod], {b3[j]}, n);
instance->voices[j].vco1PhaseGen.process({b3[j]}, {b4[j]}, {b3[j]}, n);
}
if (instance->params[p_vco1_waveform] >= (1.f / 4.f + 1.f / 2.f)) {
instance->vco1OscTri.process(cb3, cb4, b3, n);
instance->vco1OscTri.process(b3, b4, b3, n);
instance->vco1OscPulse.reset();
} else if (instance->params[p_vco1_waveform] >= (1.f / 4.f)) {
instance->vco1OscPulse.process(cb3, cb4, b3, n);
instance->vco1OscPulse.process(b3, b4, b3, n);
instance->vco1OscTri.reset();
} else {
instance->vco1OscSaw.process(cb3, cb4, b3, n);
instance->vco1OscSaw.process(b3, b4, b3, n);
instance->vco1OscPulse.reset();
instance->vco1OscTri.reset();
}
for (int j = 0; j < N_VOICES; j++) {
bufScale<1>({xb2[j]}, instance->params[p_vco2_mod], {xb2[j]}, n);
instance->voices[j].vco2PhaseGen.process({b2.data()[j]}, {b2.data()[j]}, {b4.data()[j]}, n);
bufScale<1>({b2[j]}, instance->params[p_vco2_mod], {b2[j]}, n);
instance->voices[j].vco2PhaseGen.process({b2[j]}, {b2[j]}, {b4[j]}, n);
}
if (instance->params[p_vco2_waveform] >= (1.f / 4.f + 1.f / 2.f)) {
instance->vco2OscTri.process(cb2, cb4, b2, n);
instance->vco2OscTri.process(b2, b4, b2, n);
instance->vco2OscPulse.reset();
} else if (instance->params[p_vco2_waveform] >= (1.f / 4.f)) {
instance->vco2OscPulse.process(cb2, cb4, b2, n);
instance->vco2OscPulse.process(b2, b4, b2, n);
instance->vco2OscTri.reset();
} else {
instance->vco2OscSaw.process(cb2, cb4, b2, n);
instance->vco2OscSaw.process(b2, b4, b2, n);
instance->vco2OscPulse.reset();
instance->vco2OscTri.reset();
}
instance->vco1Gain.process(cb3, b3, n);
instance->vco2Gain.process(cb2, b2, n);
instance->vco3Gain.process(cb0, b0, n);
instance->noiseGain.process(cb1, b1, n);
bufMix<N_VOICES>(xb0, xb2, xb0, n);
bufMix<N_VOICES>(xb0, xb3, xb0, n);
instance->vco1Gain.process(b3, b3, n);
instance->vco2Gain.process(b2, b2, n);
instance->vco3Gain.process(b0, b0, n);
instance->noiseGain.process(b1, b1, n);
bufMix<N_VOICES>(b0, b2, b0, n);
bufMix<N_VOICES>(b0, b3, b0, n);
instance->oscFilt.process(cb0, b0, n);
instance->oscFilt.process(b0, b0, n);
const float k = instance->params[p_noise_color] >= 0.5f
? 6.f * instance->noiseGen.getScalingK() * instance->pinkFilt.getScalingK()
: 0.1f * instance->noiseGen.getScalingK();
bufScale<N_VOICES>(xb1, k, xb1, n);
bufMix<N_VOICES>(xb0, xb1, xb0, n);
bufScale<N_VOICES>(b1, k, b1, n);
bufMix<N_VOICES>(b0, b1, b0, n);
instance->vcfEnvGen.process(gates, na, n);
instance->vcfEnvGen.process(xgates, na, n);
for (int j = 0; j < N_VOICES; j++) {
float v = instance->params[p_vcf_cutoff] + instance->params[p_vcf_contour] * instance->vcfEnvGen.getYZ1(j) + vcf_mod[j];
float cutoff = 20.f + (20e3f - 20.f) * v * v * v;
@ -282,15 +270,15 @@ void bw_example_synthpp_poly_process(bw_example_synthpp_poly *instance, const fl
cutoff *= bw_pow2f((0.629960524947437f * 8.333333333333333e-2f) * (instance->voices[j].note - 60));
// otherwise no kbd control
instance->voices[j].vcf.setCutoff(bw_clipf(cutoff, 20.f, 20e3f));
instance->voices[j].vcf.process({b0.data()[j]}, {b0.data()[j]}, {nullptr}, {nullptr}, n);
instance->voices[j].vcf.process({b0[j]}, {b0[j]}, {nullptr}, {nullptr}, n);
}
instance->vcaEnvGen.process(gates, b1, n);
bufMul<N_VOICES>(xb0, xb1, xb0, n);
instance->vcaEnvGen.process(xgates, b1, n);
bufMul<N_VOICES>(b0, b1, b0, n);
bufFill<1>(0.f, {out}, n);
for (int j = 0; j < N_VOICES; j++)
bufMix<1>({out}, {xb0[j]}, {out}, n);
bufMix<1>({out}, {b0[j]}, {out}, n);
instance->a440PhaseGen.process({nullptr}, {instance->buf}, {nullptr}, n);
oscSinProcess<1>({instance->buf}, {instance->buf}, n);

8
include/bw_ap1.h
View File

@ -145,7 +145,7 @@ static inline void bw_ap1_process(bw_ap1_coeffs *BW_RESTRICT coeffs, bw_ap1_stat
*
* #### bw_ap1_process_multi()
* ```>>> */
static inline void bw_ap1_process_multi(bw_ap1_coeffs *BW_RESTRICT coeffs, bw_ap1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_ap1_process_multi(bw_ap1_coeffs *BW_RESTRICT coeffs, bw_ap1_state * 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
@ -222,7 +222,7 @@ static inline void bw_ap1_process(bw_ap1_coeffs *BW_RESTRICT coeffs, bw_ap1_stat
}
}
static inline void bw_ap1_process_multi(bw_ap1_coeffs *BW_RESTRICT coeffs, bw_ap1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_ap1_process_multi(bw_ap1_coeffs *BW_RESTRICT coeffs, bw_ap1_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_ap1_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_ap1_update_coeffs_audio(coeffs);
@ -256,7 +256,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -302,7 +302,7 @@ inline void AP1<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void AP1<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_ap1_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_ap2.h
View File

@ -143,7 +143,7 @@ static inline void bw_ap2_process(bw_ap2_coeffs *BW_RESTRICT coeffs, bw_ap2_stat
*
* #### bw_ap2_process_multi()
* ```>>> */
static inline void bw_ap2_process_multi(bw_ap2_coeffs *BW_RESTRICT coeffs, bw_ap2_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_ap2_process_multi(bw_ap2_coeffs *BW_RESTRICT coeffs, bw_ap2_state * 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
@ -232,7 +232,7 @@ static inline void bw_ap2_process(bw_ap2_coeffs *BW_RESTRICT coeffs, bw_ap2_stat
}
}
static inline void bw_ap2_process_multi(bw_ap2_coeffs *BW_RESTRICT coeffs, bw_ap2_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_ap2_process_multi(bw_ap2_coeffs *BW_RESTRICT coeffs, bw_ap2_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_ap2_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_ap2_update_coeffs_audio(coeffs);
@ -270,7 +270,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -317,7 +317,7 @@ inline void AP2<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void AP2<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_ap2_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

12
include/bw_balance.h
View File

@ -128,7 +128,7 @@ static inline void bw_balance_process(bw_balance_coeffs *BW_RESTRICT coeffs, con
*
* #### bw_balance_process_multi()
* ```>>> */
static inline void bw_balance_process_multi(bw_balance_coeffs *BW_RESTRICT coeffs, const float * const *x_l, const float * const *x_r, float **y_l, float **y_r, size_t n_channels, size_t n_samples);
static inline void bw_balance_process_multi(bw_balance_coeffs *BW_RESTRICT coeffs, const float * const *x_l, const float * const *x_r, float * const *y_l, float * const *y_r, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x_l`
* (left) and `x_r` (right) and fills the first `n_samples` of the
@ -220,7 +220,7 @@ static inline void bw_balance_process(bw_balance_coeffs *BW_RESTRICT coeffs, con
}
}
static inline void bw_balance_process_multi(bw_balance_coeffs *BW_RESTRICT coeffs, const float * const *x_l, const float * const *x_r, float **y_l, float **y_r, size_t n_channels, size_t n_samples) {
static inline void bw_balance_process_multi(bw_balance_coeffs *BW_RESTRICT coeffs, const float * const *x_l, const float * const *x_r, float * const *y_l, float * const *y_r, size_t n_channels, size_t n_samples) {
bw_balance_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_balance_update_coeffs_audio(coeffs);
@ -255,8 +255,8 @@ public:
void process(
const float * const *x_l,
const float * const *x_r,
float **y_l,
float **y_r,
float * const *y_l,
float * const *y_r,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x_l,
@ -299,8 +299,8 @@ template<size_t N_CHANNELS>
inline void Balance<N_CHANNELS>::process(
const float * const *x_l,
const float * const *x_r,
float **y_l,
float **y_r,
float * const *y_l,
float * const *y_r,
size_t nSamples) {
bw_balance_process_multi(&coeffs, x_l, x_r, y_l, y_r, N_CHANNELS, nSamples);
}

8
include/bw_bd_reduce.h
View File

@ -126,7 +126,7 @@ static inline void bw_bd_reduce_process(bw_bd_reduce_coeffs *BW_RESTRICT coeffs,
*
* #### bw_bd_reduce_process_multi()
* ```>>> */
static inline void bw_bd_reduce_process_multi(bw_bd_reduce_coeffs *BW_RESTRICT coeffs, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_bd_reduce_process_multi(bw_bd_reduce_coeffs *BW_RESTRICT coeffs, 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
@ -199,7 +199,7 @@ static inline void bw_bd_reduce_process(bw_bd_reduce_coeffs *BW_RESTRICT coeffs,
y[i] = bw_bd_reduce_process1(coeffs, x[i]);
}
static inline void bw_bd_reduce_process_multi(bw_bd_reduce_coeffs *BW_RESTRICT coeffs, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_bd_reduce_process_multi(bw_bd_reduce_coeffs *BW_RESTRICT coeffs, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_bd_reduce_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++)
for (size_t j = 0; j < n_channels; j++)
@ -230,7 +230,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -265,7 +265,7 @@ inline void BDReduce<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void BDReduce<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_bd_reduce_process_multi(&coeffs, x, y, N_CHANNELS, nSamples);
}

58
include/bw_buf.h
View File

@ -123,14 +123,14 @@ static inline void bw_buf_mul(const float *src1, const float *src2, float *dest,
*
* #### bw_buf_fill_multi()
* ```>>> */
static inline void bw_buf_fill_multi(float k, float **dest, size_t n_channels, size_t n_elems);
static inline void bw_buf_fill_multi(float k, float * const *dest, size_t n_channels, size_t n_elems);
/*! <<<```
* Sets the first `n_elems` in each of the `n_channels` buffers `dest` to
* `k`.
*
* #### bw_buf_neg_multi()
* ```>>> */
static inline void bw_buf_neg_multi(const float * const *src, float **dest, size_t n_channels, size_t n_elems);
static inline void bw_buf_neg_multi(const float * const *src, float * const *dest, size_t n_channels, size_t n_elems);
/*! <<<```
* Inverts the sign of the first `n_elems` in each of the `n_channels`
* buffers `src` and stores the results in the first `n_elems` in each of the
@ -138,7 +138,7 @@ static inline void bw_buf_neg_multi(const float * const *src, float **dest, size
*
* #### bw_buf_add_multi()
* ```>>> */
static inline void bw_buf_add_multi(const float * const *src, float k, float **dest, size_t n_channels, size_t n_elems);
static inline void bw_buf_add_multi(const float * const *src, float k, float * const *dest, size_t n_channels, size_t n_elems);
/*! <<<```
* Adds `k` to the first `n_elems` in each of the `n_channels` buffers `src`
* and stores the results in the first `n_elems` in each of the `n_channels`
@ -146,7 +146,7 @@ static inline void bw_buf_add_multi(const float * const *src, float k, float **d
*
* #### bw_buf_scale_multi()
* ```>>> */
static inline void bw_buf_scale_multi(const float * const *src, float k, float **dest, size_t n_channels, size_t n_elems);
static inline void bw_buf_scale_multi(const float * const *src, float k, float * const *dest, size_t n_channels, size_t n_elems);
/*! <<<```
* Multiplies the first `n_elems` in each of the `n_channels` buffers `src`
* by `k` and stores the results in the first `n_elems` in each of the
@ -154,7 +154,7 @@ static inline void bw_buf_scale_multi(const float * const *src, float k, float *
*
* #### bw_buf_mix_multi()
* ```>>> */
static inline void bw_buf_mix_multi(const float * const *src1, const float * const *src2, float **dest, size_t n_channels, size_t n_elems);
static inline void bw_buf_mix_multi(const float * const *src1, const float * const *src2, float * const *dest, size_t n_channels, size_t n_elems);
/*! <<<```
* Adds the first `n_elems` in each of the `n_channels` buffers `src1` and
* `src2` and stores the results in the first `n_elems` in each of the
@ -162,7 +162,7 @@ static inline void bw_buf_mix_multi(const float * const *src1, const float * con
*
* #### bw_buf_mul_multi()
* ```>>> */
static inline void bw_buf_mul_multi(const float * const *src1, const float * const *src2, float **dest, size_t n_channels, size_t n_elems);
static inline void bw_buf_mul_multi(const float * const *src1, const float * const *src2, float * const *dest, size_t n_channels, size_t n_elems);
/*! <<<```
* Multiplies the first `n_elems` in each of the `n_channels` buffers `src1`
* and `src2` and stores the results in the first `n_elems` in each of the
@ -246,42 +246,42 @@ static inline void bw_buf_mul(const float *src1, const float *src2, float *dest,
BW_ASSERT_DEEP(!bw_has_nan(dest, n_elems));
}
static inline void bw_buf_fill_multi(float k, float **dest, size_t n_channels, size_t n_elems) {
static inline void bw_buf_fill_multi(float k, float * const *dest, size_t n_channels, size_t n_elems) {
BW_ASSERT(!(dest == NULL && n_channels != 0));
for (size_t i = 0; i < n_channels; i++)
bw_buf_fill(k, dest[i], n_elems);
}
static inline void bw_buf_neg_multi(const float * const *src, float **dest, size_t n_channels, size_t n_elems) {
static inline void bw_buf_neg_multi(const float * const *src, float * const *dest, size_t n_channels, size_t n_elems) {
BW_ASSERT(!((dest == NULL || src == NULL) && n_channels != 0));
for (size_t i = 0; i < n_channels; i++)
bw_buf_neg(src[i], dest[i], n_elems);
}
static inline void bw_buf_add_multi(const float * const *src, float k, float **dest, size_t n_channels, size_t n_elems) {
static inline void bw_buf_add_multi(const float * const *src, float k, float * const *dest, size_t n_channels, size_t n_elems) {
BW_ASSERT(!((dest == NULL || src == NULL) && n_channels != 0));
for (size_t i = 0; i < n_channels; i++)
bw_buf_add(src[i], k, dest[i], n_elems);
}
static inline void bw_buf_scale_multi(const float * const *src, float k, float **dest, size_t n_channels, size_t n_elems) {
static inline void bw_buf_scale_multi(const float * const *src, float k, float * const *dest, size_t n_channels, size_t n_elems) {
BW_ASSERT(!((dest == NULL || src == NULL) && n_channels != 0));
for (size_t i = 0; i < n_channels; i++)
bw_buf_scale(src[i], k, dest[i], n_elems);
}
static inline void bw_buf_mix_multi(const float * const *src1, const float * const *src2, float **dest, size_t n_channels, size_t n_elems) {
static inline void bw_buf_mix_multi(const float * const *src1, const float * const *src2, float * const *dest, size_t n_channels, size_t n_elems) {
BW_ASSERT(!((dest == NULL || src1 == NULL || src2 == NULL) && n_channels != 0));
for (size_t i = 0; i < n_channels; i++)
bw_buf_mix(src1[i], src2[i], dest[i], n_elems);
}
static inline void bw_buf_mul_multi(const float * const *src1, const float * const *src2, float **dest, size_t n_channels, size_t n_elems) {
static inline void bw_buf_mul_multi(const float * const *src1, const float * const *src2, float * const *dest, size_t n_channels, size_t n_elems) {
BW_ASSERT(!((dest == NULL || src1 == NULL || src2 == NULL) && n_channels != 0));
for (size_t i = 0; i < n_channels; i++)
@ -303,7 +303,7 @@ namespace Brickworks {
template<size_t N_CHANNELS>
inline void bufFill(
float k,
float ** dest,
float * const * dest,
int nSamples);
template<size_t N_CHANNELS>
@ -318,7 +318,7 @@ inline void bufFill(
template<size_t N_CHANNELS>
inline void bufNeg(
const float * const *src,
float **dest,
float * const *dest,
int nSamples);
template<size_t N_CHANNELS>
@ -333,7 +333,7 @@ inline void bufNeg(
template<size_t N_CHANNELS>
inline void bufAdd(
const float * const *src,
float **dest,
float * const *dest,
float k,
int nSamples);
@ -351,7 +351,7 @@ template<size_t N_CHANNELS>
inline void bufScale(
const float * const *src,
float k,
float **dest,
float * const *dest,
int nSamples);
template<size_t N_CHANNELS>
@ -368,7 +368,7 @@ template<size_t N_CHANNELS>
inline void bufMix(
const float * const *src1,
const float * const *src2,
float **dest,
float * const *dest,
int nSamples);
template<size_t N_CHANNELS>
@ -385,7 +385,7 @@ template<size_t N_CHANNELS>
inline void bufMul(
const float * const *src1,
const float * const *src2,
float **dest,
float * const *dest,
int nSamples);
template<size_t N_CHANNELS>
@ -405,7 +405,7 @@ inline void bufMul(
template<size_t N_CHANNELS>
inline void bufFill(
float k,
float ** dest,
float * const * dest,
int nSamples) {
bw_buf_fill_multi(k, dest, N_CHANNELS, nSamples);
}
@ -421,7 +421,7 @@ inline void bufFill(
template<size_t N_CHANNELS>
inline void bufNeg(
const float * const *src,
float **dest,
float * const *dest,
int nSamples) {
bw_buf_neg_multi(src, dest, N_CHANNELS, nSamples);
}
@ -431,13 +431,13 @@ inline void bufNeg(
std::array<const float *, N_CHANNELS> src,
std::array<float *, N_CHANNELS> dest,
int nSamples) {
bufNeg<N_CHANNELS>(src, dest, nSamples);
bufNeg<N_CHANNELS>(src.data(), dest.data(), nSamples);
}
template<size_t N_CHANNELS>
inline void bufAdd(
const float * const *src,
float **dest,
float * const *dest,
float k,
int nSamples) {
bw_buf_add_multi(src, k, dest, N_CHANNELS, nSamples);
@ -449,14 +449,14 @@ inline void bufAdd(
float k,
std::array<float *, N_CHANNELS> dest,
int nSamples) {
bufAdd<N_CHANNELS>(src, k, dest, nSamples);
bufAdd<N_CHANNELS>(src.data(), k, dest.data(), nSamples);
}
template<size_t N_CHANNELS>
inline void bufScale(
const float * const *src,
float k,
float **dest,
float * const *dest,
int nSamples) {
bw_buf_scale_multi(src, k, dest, N_CHANNELS, nSamples);
}
@ -467,14 +467,14 @@ inline void bufScale(
float k,
std::array<float *, N_CHANNELS> dest,
int nSamples) {
bufScale<N_CHANNELS>(src, k, dest, nSamples);
bufScale<N_CHANNELS>(src.data(), k, dest.data(), nSamples);
}
template<size_t N_CHANNELS>
inline void bufMix(
const float * const *src1,
const float * const *src2,
float **dest,
float * const *dest,
int nSamples) {
bw_buf_mix_multi(src1, src2, dest, N_CHANNELS, nSamples);
}
@ -485,14 +485,14 @@ inline void bufMix(
std::array<const float *, N_CHANNELS> src2,
std::array<float *, N_CHANNELS> dest,
int nSamples) {
bufMix<N_CHANNELS>(src1, src2, dest, nSamples);
bufMix<N_CHANNELS>(src1.data(), src2.data(), dest.data(), nSamples);
}
template<size_t N_CHANNELS>
inline void bufMul(
const float * const *src1,
const float * const *src2,
float **dest,
float * const *dest,
int nSamples) {
bw_buf_mul_multi(src1, src2, dest, N_CHANNELS, nSamples);
}
@ -503,7 +503,7 @@ inline void bufMul(
std::array<const float *, N_CHANNELS> src2,
std::array<float *, N_CHANNELS> dest,
int nSamples) {
bufMul<N_CHANNELS>(src1, src2, dest, nSamples);
bufMul<N_CHANNELS>(src1.data(), src2.data(), dest.data(), nSamples);
}
}

8
include/bw_chorus.h
View File

@ -162,7 +162,7 @@ static inline void bw_chorus_process(bw_chorus_coeffs *BW_RESTRICT coeffs, bw_ch
*
* #### bw_chorus_process_multi()
* ```>>> */
static inline void bw_chorus_process_multi(bw_chorus_coeffs *BW_RESTRICT coeffs, bw_chorus_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_chorus_process_multi(bw_chorus_coeffs *BW_RESTRICT coeffs, bw_chorus_state * 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
@ -310,7 +310,7 @@ static inline void bw_chorus_process(bw_chorus_coeffs *BW_RESTRICT coeffs, bw_ch
}
}
static inline void bw_chorus_process_multi(bw_chorus_coeffs *BW_RESTRICT coeffs, bw_chorus_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_chorus_process_multi(bw_chorus_coeffs *BW_RESTRICT coeffs, bw_chorus_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_chorus_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_chorus_update_coeffs_audio(coeffs);
@ -366,7 +366,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -432,7 +432,7 @@ inline void Chorus<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Chorus<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_chorus_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_clip.h
View File

@ -145,7 +145,7 @@ static inline void bw_clip_process(bw_clip_coeffs *BW_RESTRICT coeffs, bw_clip_s
*
* #### bw_clip_process_multi()
* ```>>> */
static inline void bw_clip_process_multi(bw_clip_coeffs *BW_RESTRICT coeffs, bw_clip_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_clip_process_multi(bw_clip_coeffs *BW_RESTRICT coeffs, bw_clip_state * 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
@ -293,7 +293,7 @@ static inline void bw_clip_process(bw_clip_coeffs *BW_RESTRICT coeffs, bw_clip_s
}
}
static inline void bw_clip_process_multi(bw_clip_coeffs *BW_RESTRICT coeffs, bw_clip_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_clip_process_multi(bw_clip_coeffs *BW_RESTRICT coeffs, bw_clip_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
if (coeffs->gain_compensation)
for (size_t i = 0; i < n_samples; i++) {
bw_clip_update_coeffs_audio(coeffs);
@ -341,7 +341,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -389,7 +389,7 @@ inline void Clip<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Clip<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_clip_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_comb.h
View File

@ -163,7 +163,7 @@ static inline void bw_comb_process(bw_comb_coeffs *BW_RESTRICT coeffs, bw_comb_s
*
* #### bw_comb_process_multi()
* ```>>> */
static inline void bw_comb_process_multi(bw_comb_coeffs *BW_RESTRICT coeffs, bw_comb_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_comb_process_multi(bw_comb_coeffs *BW_RESTRICT coeffs, bw_comb_state * 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
@ -361,7 +361,7 @@ static inline void bw_comb_process(bw_comb_coeffs *BW_RESTRICT coeffs, bw_comb_s
}
}
static inline void bw_comb_process_multi(bw_comb_coeffs *BW_RESTRICT coeffs, bw_comb_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_comb_process_multi(bw_comb_coeffs *BW_RESTRICT coeffs, bw_comb_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_comb_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_comb_update_coeffs_audio(coeffs);
@ -412,7 +412,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -477,7 +477,7 @@ inline void Comb<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Comb<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_comb_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_comp.h
View File

@ -141,7 +141,7 @@ static inline void bw_comp_process(bw_comp_coeffs *BW_RESTRICT coeffs, bw_comp_s
*
* #### bw_comp_process_multi()
* ```>>> */
static inline void bw_comp_process_multi(bw_comp_coeffs *BW_RESTRICT coeffs, bw_comp_state * const *BW_RESTRICT state, const float * const *x, const float * const *x_sc, float **y, size_t n_channels, size_t n_samples);
static inline void bw_comp_process_multi(bw_comp_coeffs *BW_RESTRICT coeffs, bw_comp_state * const *BW_RESTRICT state, const float * const *x, const float * const *x_sc, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x` and
* the first `n_samples` of the `n_channels` sidechain input buffers `x_sc`,
@ -302,7 +302,7 @@ static inline void bw_comp_process(bw_comp_coeffs *BW_RESTRICT coeffs, bw_comp_s
}
}
static inline void bw_comp_process_multi(bw_comp_coeffs *BW_RESTRICT coeffs, bw_comp_state * const *BW_RESTRICT state, const float * const *x, const float * const *x_sc, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_comp_process_multi(bw_comp_coeffs *BW_RESTRICT coeffs, bw_comp_state * const *BW_RESTRICT state, const float * const *x, const float * const *x_sc, float * const *y, size_t n_channels, size_t n_samples) {
bw_comp_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_comp_update_coeffs_audio(coeffs);
@ -361,7 +361,7 @@ public:
void process(
const float * const *x,
const float * const *xSC,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -415,7 +415,7 @@ template<size_t N_CHANNELS>
inline void Comp<N_CHANNELS>::process(
const float * const *x,
const float * const *xSC,
float **y,
float * const *y,
size_t nSamples) {
bw_comp_process_multi(&coeffs, statesP, x, xSC, y, N_CHANNELS, nSamples);
}

8
include/bw_delay.h
View File

@ -173,7 +173,7 @@ static inline void bw_delay_process(bw_delay_coeffs *BW_RESTRICT coeffs, bw_dela
*
* #### bw_delay_process_multi()
* ```>>> */
static inline void bw_delay_process_multi(bw_delay_coeffs *BW_RESTRICT coeffs, bw_delay_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_delay_process_multi(bw_delay_coeffs *BW_RESTRICT coeffs, bw_delay_state * 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
@ -295,7 +295,7 @@ static inline void bw_delay_process(bw_delay_coeffs *BW_RESTRICT coeffs, bw_dela
y[i] = bw_delay_process1(coeffs, state, x[i]);
}
static inline void bw_delay_process_multi(bw_delay_coeffs *BW_RESTRICT coeffs, bw_delay_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_delay_process_multi(bw_delay_coeffs *BW_RESTRICT coeffs, bw_delay_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_delay_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++)
for (size_t j = 0; j < n_channels; j++)
@ -335,7 +335,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -401,7 +401,7 @@ inline void Delay<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Delay<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_delay_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_dist.h
View File

@ -134,7 +134,7 @@ static inline void bw_dist_process(bw_dist_coeffs *BW_RESTRICT coeffs, bw_dist_s
*
* #### bw_dist_process_multi()
* ```>>> */
static inline void bw_dist_process_multi(bw_dist_coeffs *BW_RESTRICT coeffs, bw_dist_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_dist_process_multi(bw_dist_coeffs *BW_RESTRICT coeffs, bw_dist_state * 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
@ -278,7 +278,7 @@ static inline void bw_dist_process(bw_dist_coeffs *BW_RESTRICT coeffs, bw_dist_s
}
}
static inline void bw_dist_process_multi(bw_dist_coeffs *BW_RESTRICT coeffs, bw_dist_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_dist_process_multi(bw_dist_coeffs *BW_RESTRICT coeffs, bw_dist_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_dist_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_dist_update_coeffs_audio(coeffs);
@ -320,7 +320,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -368,7 +368,7 @@ inline void Dist<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Dist<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_dist_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_drive.h
View File

@ -133,7 +133,7 @@ static inline void bw_drive_process(bw_drive_coeffs *BW_RESTRICT coeffs, bw_driv
*
* #### bw_drive_process_multi()
* ```>>> */
static inline void bw_drive_process_multi(bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_drive_process_multi(bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state * 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
@ -267,7 +267,7 @@ static inline void bw_drive_process(bw_drive_coeffs *BW_RESTRICT coeffs, bw_driv
}
}
static inline void bw_drive_process_multi(bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_drive_process_multi(bw_drive_coeffs *BW_RESTRICT coeffs, bw_drive_state * 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);
@ -309,7 +309,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -357,7 +357,7 @@ inline void Drive<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Drive<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_drive_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_drywet.h
View File

@ -117,7 +117,7 @@ static inline void bw_drywet_process(bw_drywet_coeffs *BW_RESTRICT coeffs, const
*
* #### bw_drywet_process_multi()
* ```>>> */
static inline void bw_drywet_process_multi(bw_drywet_coeffs *BW_RESTRICT coeffs, const float * const *x_dry, const float * const *x_wet, float **y, size_t n_channels, size_t n_samples);
static inline void bw_drywet_process_multi(bw_drywet_coeffs *BW_RESTRICT coeffs, const float * const *x_dry, const float * const *x_wet, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` dry input buffers
* `x_dry` and of the `n_channels` wet input buffers `x_wet`, and fills the
@ -193,7 +193,7 @@ static inline void bw_drywet_process(bw_drywet_coeffs *BW_RESTRICT coeffs, const
}
}
static inline void bw_drywet_process_multi(bw_drywet_coeffs *BW_RESTRICT coeffs, const float * const *x_dry, const float * const *x_wet, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_drywet_process_multi(bw_drywet_coeffs *BW_RESTRICT coeffs, const float * const *x_dry, const float * const *x_wet, float * const *y, size_t n_channels, size_t n_samples) {
bw_drywet_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_drywet_update_coeffs_audio(coeffs);
@ -232,7 +232,7 @@ public:
void process(
const float * const *x_dry,
const float * const *x_wet,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x_dry,
@ -275,7 +275,7 @@ template<size_t N_CHANNELS>
inline void DryWet<N_CHANNELS>::process(
const float * const *x_dry,
const float * const *x_wet,
float **y,
float * const *y,
size_t nSamples) {
bw_drywet_process_multi(&coeffs, x_dry, x_wet, y, N_CHANNELS, nSamples);
}

8
include/bw_env_follow.h
View File

@ -148,7 +148,7 @@ static inline void bw_env_follow_process(bw_env_follow_coeffs *BW_RESTRICT coeff
*
* #### bw_env_follow_process_multi()
* ```>>> */
static inline void bw_env_follow_process_multi(bw_env_follow_coeffs *BW_RESTRICT coeffs, bw_env_follow_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_env_follow_process_multi(bw_env_follow_coeffs *BW_RESTRICT coeffs, bw_env_follow_state * 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
@ -250,7 +250,7 @@ static inline void bw_env_follow_process(bw_env_follow_coeffs *BW_RESTRICT coeff
}
}
static inline void bw_env_follow_process_multi(bw_env_follow_coeffs *BW_RESTRICT coeffs, bw_env_follow_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_env_follow_process_multi(bw_env_follow_coeffs *BW_RESTRICT coeffs, bw_env_follow_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_env_follow_update_coeffs_ctrl(coeffs);
if (y != NULL)
for (size_t i = 0; i < n_samples; i++) {
@ -302,7 +302,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -351,7 +351,7 @@ inline void EnvFollow<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void EnvFollow<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_env_follow_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_env_gen.h
View File

@ -194,7 +194,7 @@ static inline void bw_env_gen_process(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_
*
* #### bw_env_gen_process_multi()
* ```>>> */
static inline void bw_env_gen_process_multi(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state * const *BW_RESTRICT state, const char *gate, float **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 * const *BW_RESTRICT state, const char *gate, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Generates and fills the first `n_samples` of the `n_channels` output
* buffers `y` using the given `n_channels` `gate` values (`0` for off,
@ -400,7 +400,7 @@ static inline void bw_env_gen_process(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_
bw_env_gen_process1(coeffs, state);
}
static inline void bw_env_gen_process_multi(bw_env_gen_coeffs *BW_RESTRICT coeffs, bw_env_gen_state * const *BW_RESTRICT state, const char *gate, float **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 * const *BW_RESTRICT state, const char *gate, float * const *y, size_t n_channels, size_t n_samples) {
bw_env_gen_update_coeffs_ctrl(coeffs);
for (size_t j = 0; j < n_channels; j++)
bw_env_gen_update_state_ctrl(coeffs, state[j], gate[j]);
@ -479,7 +479,7 @@ public:
void reset();
void process(
const char *gate,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<char, N_CHANNELS> gate,
@ -531,7 +531,7 @@ inline void EnvGen<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void EnvGen<N_CHANNELS>::process(
const char *gate,
float **y,
float * const *y,
size_t nSamples) {
bw_env_gen_process_multi(&coeffs, statesP, gate, y, N_CHANNELS, nSamples);
}

8
include/bw_fuzz.h
View File

@ -134,7 +134,7 @@ 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 * const *BW_RESTRICT state, const float * const *x, float **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 * 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
@ -260,7 +260,7 @@ static inline void bw_fuzz_process(bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_s
}
}
static inline void bw_fuzz_process_multi(bw_fuzz_coeffs *BW_RESTRICT coeffs, bw_fuzz_state * const *BW_RESTRICT state, const float * const *x, float **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 * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_fuzz_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_fuzz_update_coeffs_audio(coeffs);
@ -298,7 +298,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -345,7 +345,7 @@ inline void Fuzz<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Fuzz<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_fuzz_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_gain.h
View File

@ -137,7 +137,7 @@ static inline void bw_gain_process(bw_gain_coeffs *BW_RESTRICT coeffs, const flo
*
* #### bw_gain_process_multi()
* ```>>> */
static inline void bw_gain_process_multi(bw_gain_coeffs *BW_RESTRICT coeffs, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_gain_process_multi(bw_gain_coeffs *BW_RESTRICT coeffs, 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
@ -246,7 +246,7 @@ static inline void bw_gain_process(bw_gain_coeffs *BW_RESTRICT coeffs, const flo
}
}
static inline void bw_gain_process_multi(bw_gain_coeffs *BW_RESTRICT coeffs, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_gain_process_multi(bw_gain_coeffs *BW_RESTRICT coeffs, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_gain_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_gain_update_coeffs_audio(coeffs);
@ -292,7 +292,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -336,7 +336,7 @@ inline void Gain<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Gain<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_gain_process_multi(&coeffs, x, y, N_CHANNELS, nSamples);
}

8
include/bw_hp1.h
View File

@ -143,7 +143,7 @@ static inline void bw_hp1_process(bw_hp1_coeffs *BW_RESTRICT coeffs, bw_hp1_stat
*
* #### bw_hp1_process_multi()
* ```>>> */
static inline void bw_hp1_process_multi(bw_hp1_coeffs *BW_RESTRICT coeffs, bw_hp1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_hp1_process_multi(bw_hp1_coeffs *BW_RESTRICT coeffs, bw_hp1_state * 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
@ -220,7 +220,7 @@ static inline void bw_hp1_process(bw_hp1_coeffs *BW_RESTRICT coeffs, bw_hp1_stat
}
}
static inline void bw_hp1_process_multi(bw_hp1_coeffs *BW_RESTRICT coeffs, bw_hp1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_hp1_process_multi(bw_hp1_coeffs *BW_RESTRICT coeffs, bw_hp1_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_hp1_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_hp1_update_coeffs_audio(coeffs);
@ -254,7 +254,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -300,7 +300,7 @@ inline void HP1<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void HP1<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_hp1_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_hs1.h
View File

@ -142,7 +142,7 @@ static inline void bw_hs1_process(bw_hs1_coeffs *BW_RESTRICT coeffs, bw_hs1_stat
*
* #### bw_hs1_process_multi()
* ```>>> */
static inline void bw_hs1_process_multi(bw_hs1_coeffs *BW_RESTRICT coeffs, bw_hs1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_hs1_process_multi(bw_hs1_coeffs *BW_RESTRICT coeffs, bw_hs1_state * 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
@ -261,7 +261,7 @@ static inline void bw_hs1_process(bw_hs1_coeffs *BW_RESTRICT coeffs, bw_hs1_stat
}
}
static inline void bw_hs1_process_multi(bw_hs1_coeffs *BW_RESTRICT coeffs, bw_hs1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_hs1_process_multi(bw_hs1_coeffs *BW_RESTRICT coeffs, bw_hs1_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_hs1_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_hs1_update_coeffs_audio(coeffs);
@ -309,7 +309,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -357,7 +357,7 @@ inline void HS1<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void HS1<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_hs1_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_hs2.h
View File

@ -142,7 +142,7 @@ static inline void bw_hs2_process(bw_hs2_coeffs *BW_RESTRICT coeffs, bw_hs2_stat
*
* #### bw_hs2_process_multi()
* ```>>> */
static inline void bw_hs2_process_multi(bw_hs2_coeffs *BW_RESTRICT coeffs, bw_hs2_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_hs2_process_multi(bw_hs2_coeffs *BW_RESTRICT coeffs, bw_hs2_state * 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
@ -281,7 +281,7 @@ static inline void bw_hs2_process(bw_hs2_coeffs *BW_RESTRICT coeffs, bw_hs2_stat
}
}
static inline void bw_hs2_process_multi(bw_hs2_coeffs *BW_RESTRICT coeffs, bw_hs2_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_hs2_process_multi(bw_hs2_coeffs *BW_RESTRICT coeffs, bw_hs2_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_hs2_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_hs2_update_coeffs_audio(coeffs);
@ -336,7 +336,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -385,7 +385,7 @@ inline void HS2<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void HS2<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_hs2_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_lp1.h
View File

@ -146,7 +146,7 @@ static inline void bw_lp1_process(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_stat
*
* #### bw_lp1_process_multi()
* ```>>> */
static inline void bw_lp1_process_multi(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_lp1_process_multi(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state * 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
@ -293,7 +293,7 @@ static inline void bw_lp1_process(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_stat
}
}
static inline void bw_lp1_process_multi(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_lp1_process_multi(bw_lp1_coeffs *BW_RESTRICT coeffs, bw_lp1_state * 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++)
@ -334,7 +334,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -382,7 +382,7 @@ inline void LP1<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void LP1<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_lp1_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_ls1.h
View File

@ -143,7 +143,7 @@ static inline void bw_ls1_process(bw_ls1_coeffs *BW_RESTRICT coeffs, bw_ls1_stat
*
* #### bw_ls1_process_multi()
* ```>>> */
static inline void bw_ls1_process_multi(bw_ls1_coeffs *BW_RESTRICT coeffs, bw_ls1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_ls1_process_multi(bw_ls1_coeffs *BW_RESTRICT coeffs, bw_ls1_state * 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
@ -258,7 +258,7 @@ static inline void bw_ls1_process(bw_ls1_coeffs *BW_RESTRICT coeffs, bw_ls1_stat
}
}
static inline void bw_ls1_process_multi(bw_ls1_coeffs *BW_RESTRICT coeffs, bw_ls1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_ls1_process_multi(bw_ls1_coeffs *BW_RESTRICT coeffs, bw_ls1_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_ls1_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_ls1_update_coeffs_audio(coeffs);
@ -306,7 +306,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -354,7 +354,7 @@ inline void LS1<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void LS1<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_ls1_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_ls2.h
View File

@ -143,7 +143,7 @@ static inline void bw_ls2_process(bw_ls2_coeffs *BW_RESTRICT coeffs, bw_ls2_stat
*
* #### bw_ls2_process_multi()
* ```>>> */
static inline void bw_ls2_process_multi(bw_ls2_coeffs *BW_RESTRICT coeffs, bw_ls2_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_ls2_process_multi(bw_ls2_coeffs *BW_RESTRICT coeffs, bw_ls2_state * 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
@ -280,7 +280,7 @@ static inline void bw_ls2_process(bw_ls2_coeffs *BW_RESTRICT coeffs, bw_ls2_stat
}
}
static inline void bw_ls2_process_multi(bw_ls2_coeffs *BW_RESTRICT coeffs, bw_ls2_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_ls2_process_multi(bw_ls2_coeffs *BW_RESTRICT coeffs, bw_ls2_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_ls2_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_ls2_update_coeffs_audio(coeffs);
@ -335,7 +335,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -384,7 +384,7 @@ inline void LS2<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void LS2<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_ls2_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_mm1.h
View File

@ -142,7 +142,7 @@ static inline void bw_mm1_process(bw_mm1_coeffs *BW_RESTRICT coeffs, bw_mm1_stat
*
* #### bw_mm1_process_multi()
* ```>>> */
static inline void bw_mm1_process_multi(bw_mm1_coeffs *BW_RESTRICT coeffs, bw_mm1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_mm1_process_multi(bw_mm1_coeffs *BW_RESTRICT coeffs, bw_mm1_state * 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
@ -273,7 +273,7 @@ static inline void bw_mm1_process(bw_mm1_coeffs *BW_RESTRICT coeffs, bw_mm1_stat
}
}
static inline void bw_mm1_process_multi(bw_mm1_coeffs *BW_RESTRICT coeffs, bw_mm1_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_mm1_process_multi(bw_mm1_coeffs *BW_RESTRICT coeffs, bw_mm1_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_mm1_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_mm1_update_coeffs_audio(coeffs);
@ -323,7 +323,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -373,7 +373,7 @@ inline void MM1<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void MM1<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_mm1_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_mm2.h
View File

@ -142,7 +142,7 @@ static inline void bw_mm2_process(bw_mm2_coeffs *BW_RESTRICT coeffs, bw_mm2_stat
*
* #### bw_mm2_process_multi()
* ```>>> */
static inline void bw_mm2_process_multi(bw_mm2_coeffs *BW_RESTRICT coeffs, bw_mm2_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_mm2_process_multi(bw_mm2_coeffs *BW_RESTRICT coeffs, bw_mm2_state * 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
@ -318,7 +318,7 @@ static inline void bw_mm2_process(bw_mm2_coeffs *BW_RESTRICT coeffs, bw_mm2_stat
}
}
static inline void bw_mm2_process_multi(bw_mm2_coeffs *BW_RESTRICT coeffs, bw_mm2_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_mm2_process_multi(bw_mm2_coeffs *BW_RESTRICT coeffs, bw_mm2_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_mm2_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_mm2_update_coeffs_audio(coeffs);
@ -380,7 +380,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -433,7 +433,7 @@ inline void MM2<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void MM2<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_mm2_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_noise_gate.h
View File

@ -137,7 +137,7 @@ static inline void bw_noise_gate_process(bw_noise_gate_coeffs *BW_RESTRICT coeff
*
* #### bw_noise_gate_process_multi()
* ```>>> */
static inline void bw_noise_gate_process_multi(bw_noise_gate_coeffs *BW_RESTRICT coeffs, bw_noise_gate_state * const *BW_RESTRICT state, const float * const *x, const float * const *x_sc, float **y, size_t n_channels, size_t n_samples);
static inline void bw_noise_gate_process_multi(bw_noise_gate_coeffs *BW_RESTRICT coeffs, bw_noise_gate_state * const *BW_RESTRICT state, const float * const *x, const float * const *x_sc, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x` and
* the first `n_samples` of the `n_channels` sidechain input buffers `x_sc`,
@ -275,7 +275,7 @@ static inline void bw_noise_gate_process(bw_noise_gate_coeffs *BW_RESTRICT coeff
}
}
static inline void bw_noise_gate_process_multi(bw_noise_gate_coeffs *BW_RESTRICT coeffs, bw_noise_gate_state * const *BW_RESTRICT state, const float * const *x, const float * const *x_sc, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_noise_gate_process_multi(bw_noise_gate_coeffs *BW_RESTRICT coeffs, bw_noise_gate_state * const *BW_RESTRICT state, const float * const *x, const float * const *x_sc, float * const *y, size_t n_channels, size_t n_samples) {
bw_noise_gate_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_noise_gate_update_coeffs_audio(coeffs);
@ -326,7 +326,7 @@ public:
void process(
const float * const *x,
const float * const *xSC,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -378,7 +378,7 @@ template<size_t N_CHANNELS>
inline void NoiseGate<N_CHANNELS>::process(
const float * const *x,
const float * const *xSC,
float **y,
float * const *y,
size_t nSamples) {
bw_noise_gate_process_multi(&coeffs, statesP, x, xSC, y, N_CHANNELS, nSamples);
}

8
include/bw_noise_gen.h
View File

@ -117,7 +117,7 @@ static inline void bw_noise_gen_process(bw_noise_gen_coeffs *BW_RESTRICT coeffs,
*
* #### bw_noise_gen_process_multi()
* ```>>> */
static inline void bw_noise_gen_process_multi(bw_noise_gen_coeffs *BW_RESTRICT coeffs, float **y, size_t n_channels, size_t n_samples);
static inline void bw_noise_gen_process_multi(bw_noise_gen_coeffs *BW_RESTRICT coeffs, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Generates and fills the first `n_samples` of the `n_channels` output
* buffers `y` using `coeffs`.
@ -195,7 +195,7 @@ static inline void bw_noise_gen_process(bw_noise_gen_coeffs *BW_RESTRICT coeffs,
y[i] = bw_noise_gen_process1_scaling(coeffs);
}
static inline void bw_noise_gen_process_multi(bw_noise_gen_coeffs *BW_RESTRICT coeffs, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_noise_gen_process_multi(bw_noise_gen_coeffs *BW_RESTRICT coeffs, float * const *y, size_t n_channels, size_t n_samples) {
for (size_t i = 0; i < n_channels; i++)
bw_noise_gen_process(coeffs, y[i], n_samples);
}
@ -227,7 +227,7 @@ public:
void setSampleRate(float sampleRate);
void process(
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<float *, N_CHANNELS> y,
@ -262,7 +262,7 @@ inline void NoiseGen<N_CHANNELS>::setSampleRate(float sampleRate) {
template<size_t N_CHANNELS>
inline void NoiseGen<N_CHANNELS>::process(
float **y,
float * const *y,
size_t nSamples) {
bw_noise_gen_process_multi(&coeffs, y, N_CHANNELS, nSamples);
}

8
include/bw_notch.h
View File

@ -143,7 +143,7 @@ static inline void bw_notch_process(bw_notch_coeffs *BW_RESTRICT coeffs, bw_notc
*
* #### bw_notch_process_multi()
* ```>>> */
static inline void bw_notch_process_multi(bw_notch_coeffs *BW_RESTRICT coeffs, bw_notch_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_notch_process_multi(bw_notch_coeffs *BW_RESTRICT coeffs, bw_notch_state * 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
@ -231,7 +231,7 @@ static inline void bw_notch_process(bw_notch_coeffs *BW_RESTRICT coeffs, bw_notc
}
}
static inline void bw_notch_process_multi(bw_notch_coeffs *BW_RESTRICT coeffs, bw_notch_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_notch_process_multi(bw_notch_coeffs *BW_RESTRICT coeffs, bw_notch_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_notch_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_notch_update_coeffs_audio(coeffs);
@ -269,7 +269,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -316,7 +316,7 @@ inline void Notch<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void Notch<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_notch_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_one_pole.h
View File

@ -196,7 +196,7 @@ static inline void bw_one_pole_process(bw_one_pole_coeffs *BW_RESTRICT coeffs, b
*
* #### bw_one_pole_process_multi()
* ```>>> */
static inline void bw_one_pole_process_multi(bw_one_pole_coeffs *BW_RESTRICT coeffs, bw_one_pole_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_one_pole_process_multi(bw_one_pole_coeffs *BW_RESTRICT coeffs, bw_one_pole_state * 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
@ -706,7 +706,7 @@ static inline void bw_one_pole_process(bw_one_pole_coeffs *BW_RESTRICT coeffs, b
BW_ASSERT_DEEP(!bw_has_nan(y, n_samples));
}
static inline void bw_one_pole_process_multi(bw_one_pole_coeffs *BW_RESTRICT coeffs, bw_one_pole_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_one_pole_process_multi(bw_one_pole_coeffs *BW_RESTRICT coeffs, bw_one_pole_state * 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_one_pole_coeffs_is_valid(coeffs));
BW_ASSERT_DEEP(coeffs->state >= bw_one_pole_coeffs_state_reset_coeffs);
@ -984,7 +984,7 @@ public:
void reset(float y_z1 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -1039,7 +1039,7 @@ inline void OnePole<N_CHANNELS>::reset(float y_z1) {
template<size_t N_CHANNELS>
inline void OnePole<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_one_pole_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_osc_filt.h
View File

@ -110,7 +110,7 @@ static inline void bw_osc_filt_process(bw_osc_filt_state *BW_RESTRICT state, con
*
* #### bw_osc_filt_process_multi()
* ```>>> */
static inline void bw_osc_filt_process_multi(bw_osc_filt_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_osc_filt_process_multi(bw_osc_filt_state * 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
@ -152,7 +152,7 @@ static inline void bw_osc_filt_process(bw_osc_filt_state *BW_RESTRICT state, con
y[i] = bw_osc_filt_process1(state, x[i]);
}
static inline void bw_osc_filt_process_multi(bw_osc_filt_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_osc_filt_process_multi(bw_osc_filt_state * 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_channels; i++)
bw_osc_filt_process(state[i], x[i], y[i], n_samples);
}
@ -177,7 +177,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -213,7 +213,7 @@ inline void OscFilt<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void OscFilt<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_osc_filt_process_multi(statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_osc_pulse.h
View File

@ -147,7 +147,7 @@ static inline void bw_osc_pulse_process(bw_osc_pulse_coeffs *BW_RESTRICT coeffs,
*
* #### bw_osc_pulse_process_multi()
* ```>>> */
static inline void bw_osc_pulse_process_multi(bw_osc_pulse_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float **y, size_t n_channels, size_t n_samples);
static inline void bw_osc_pulse_process_multi(bw_osc_pulse_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x`,
* containing the normalized phase signals, and fills the first `n_samples`
@ -274,7 +274,7 @@ static inline void bw_osc_pulse_process(bw_osc_pulse_coeffs *BW_RESTRICT coeffs,
}
}
static inline void bw_osc_pulse_process_multi(bw_osc_pulse_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_osc_pulse_process_multi(bw_osc_pulse_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float * const *y, size_t n_channels, size_t n_samples) {
if (coeffs->antialiasing)
for (size_t i = 0; i < n_samples; i++) {
bw_osc_pulse_update_coeffs_audio(coeffs);
@ -319,7 +319,7 @@ public:
void process(
const float * const *x,
const float * const *x_phase_inc,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -362,7 +362,7 @@ template<size_t N_CHANNELS>
inline void OscPulse<N_CHANNELS>::process(
const float * const *x,
const float * const *x_phase_inc,
float **y,
float * const *y,
size_t nSamples) {
bw_osc_pulse_process_multi(&coeffs, x, x_phase_inc, y, N_CHANNELS, nSamples);
}

8
include/bw_osc_saw.h
View File

@ -122,7 +122,7 @@ static inline void bw_osc_saw_process(bw_osc_saw_coeffs *BW_RESTRICT coeffs, con
*
* #### bw_osc_saw_process_multi()
* ```>>> */
static inline void bw_osc_saw_process_multi(bw_osc_saw_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float **y, size_t n_channels, size_t n_samples);
static inline void bw_osc_saw_process_multi(bw_osc_saw_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x`,
* containing the normalized phase signals, and fills the first `n_samples`
@ -202,7 +202,7 @@ static inline void bw_osc_saw_process(bw_osc_saw_coeffs *BW_RESTRICT coeffs, con
y[i] = bw_osc_saw_process1(coeffs, x[i]);
}
static inline void bw_osc_saw_process_multi(bw_osc_saw_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_osc_saw_process_multi(bw_osc_saw_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float * const *y, size_t n_channels, size_t n_samples) {
if (x_phase_inc != NULL)
for (size_t i = 0; i < n_channels; i++)
bw_osc_saw_process(coeffs, x[i], x_phase_inc[i], y[i], n_samples);
@ -235,7 +235,7 @@ public:
void process(
const float * const *x,
const float * const *x_phase_inc,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -267,7 +267,7 @@ template<size_t N_CHANNELS>
inline void OscSaw<N_CHANNELS>::process(
const float * const *x,
const float * const *x_phase_inc,
float **y,
float * const *y,
size_t nSamples) {
bw_osc_saw_process_multi(&coeffs, x, x_phase_inc, y, N_CHANNELS, nSamples);
}

8
include/bw_osc_sin.h
View File

@ -96,7 +96,7 @@ static inline void bw_osc_sin_process(const float *x, float *y, size_t n_samples
*
* #### bw_osc_sin_process_multi()
* ```>>> */
static inline void bw_osc_sin_process_multi(const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_osc_sin_process_multi(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`,
* containing the normalized phase signals, and fills the first `n_samples`
@ -127,7 +127,7 @@ static inline void bw_osc_sin_process(const float *x, float *y, size_t n_samples
y[i] = bw_osc_sin_process1(x[i]);
}
static inline void bw_osc_sin_process_multi(const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_osc_sin_process_multi(const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
for (size_t i = 0; i < n_channels; i++)
bw_osc_sin_process(x[i], y[i], n_samples);
}
@ -147,7 +147,7 @@ namespace Brickworks {
template<size_t N_CHANNELS>
void oscSinProcess(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
template<size_t N_CHANNELS>
@ -166,7 +166,7 @@ void oscSinProcess(
template<size_t N_CHANNELS>
inline void oscSinProcess(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_osc_sin_process_multi(x, y, N_CHANNELS, nSamples);
}

8
include/bw_osc_tri.h
View File

@ -149,7 +149,7 @@ static inline void bw_osc_tri_process(bw_osc_tri_coeffs *BW_RESTRICT coeffs, con
*
* #### bw_osc_tri_process_multi()
* ```>>> */
static inline void bw_osc_tri_process_multi(bw_osc_tri_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float **y, size_t n_channels, size_t n_samples);
static inline void bw_osc_tri_process_multi(bw_osc_tri_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x`,
* containing the normalized phase signals, and fills the first `n_samples`
@ -282,7 +282,7 @@ static inline void bw_osc_tri_process(bw_osc_tri_coeffs *BW_RESTRICT coeffs, con
}
}
static inline void bw_osc_tri_process_multi(bw_osc_tri_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_osc_tri_process_multi(bw_osc_tri_coeffs *BW_RESTRICT coeffs, const float * const *x, const float * const *x_phase_inc, float * const *y, size_t n_channels, size_t n_samples) {
if (coeffs->antialiasing)
for (size_t i = 0; i < n_samples; i++) {
bw_osc_tri_update_coeffs_audio(coeffs);
@ -327,7 +327,7 @@ public:
void process(
const float * const *x,
const float * const *x_phase_inc,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -370,7 +370,7 @@ template<size_t N_CHANNELS>
inline void OscTri<N_CHANNELS>::process(
const float * const *x,
const float * const *x_phase_inc,
float **y,
float * const *y,
size_t nSamples) {
bw_osc_tri_process_multi(&coeffs, x, x_phase_inc, y, N_CHANNELS, nSamples);
}

12
include/bw_pan.h
View File

@ -127,7 +127,7 @@ static inline void bw_pan_process(bw_pan_coeffs *BW_RESTRICT coeffs, const float
*
* #### bw_pan_process_multi()
* ```>>> */
static inline void bw_pan_process_multi(bw_pan_coeffs *BW_RESTRICT coeffs, const float * const *x, float **y_l, float **y_r, size_t n_channels, size_t n_samples);
static inline void bw_pan_process_multi(bw_pan_coeffs *BW_RESTRICT coeffs, const float * const *x, float * const *y_l, float * const *y_r, 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_l`
@ -220,7 +220,7 @@ static inline void bw_pan_process(bw_pan_coeffs *BW_RESTRICT coeffs, const float
}
}
static inline void bw_pan_process_multi(bw_pan_coeffs *BW_RESTRICT coeffs, const float * const *x, float **y_l, float **y_r, size_t n_channels, size_t n_samples) {
static inline void bw_pan_process_multi(bw_pan_coeffs *BW_RESTRICT coeffs, const float * const *x, float * const *y_l, float * const *y_r, size_t n_channels, size_t n_samples) {
bw_pan_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_pan_update_coeffs_audio(coeffs);
@ -254,8 +254,8 @@ public:
void reset();
void process(
const float * const *x,
float **y_l,
float **y_r,
float * const *y_l,
float * const *y_r,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -296,8 +296,8 @@ inline void Pan<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::process(
const float * const *x,
float **y_l,
float **y_r,
float * const *y_l,
float * const *y_r,
size_t nSamples) {
bw_pan_process_multi(&coeffs, x, y_l, y_r, N_CHANNELS, nSamples);
}

8
include/bw_peak.h
View File

@ -152,7 +152,7 @@ static inline void bw_peak_process(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_s
*
* #### bw_peak_process_multi()
* ```>>> */
static inline void bw_peak_process_multi(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_peak_process_multi(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state * 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
@ -315,7 +315,7 @@ static inline void bw_peak_process(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_s
}
}
static inline void bw_peak_process_multi(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_peak_process_multi(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_peak_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_peak_update_coeffs_audio(coeffs);
@ -385,7 +385,7 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -436,7 +436,7 @@ inline void Peak<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_peak_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

12
include/bw_phase_gen.h
View File

@ -165,7 +165,7 @@ static inline void bw_phase_gen_process(bw_phase_gen_coeffs *BW_RESTRICT coeffs,
*
* #### bw_phase_gen_process_multi()
* ```>>> */
static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state * const *BW_RESTRICT state, const float * const *x_mod, float **y, float **y_phase_inc, size_t n_channels, size_t n_samples);
static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state * const *BW_RESTRICT state, const float * const *x_mod, float * const *y, float * const *y_phase_inc, size_t n_channels, size_t n_samples);
/*! <<<```
* Generates and fills the first `n_samples` of the `n_channels` output
* buffers `y`, while using and updating both the common `coeffs` and each of
@ -342,7 +342,7 @@ static inline void bw_phase_gen_process(bw_phase_gen_coeffs *BW_RESTRICT coeffs,
}
}
static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state * const *BW_RESTRICT state, const float * const *x_mod, float **y, float **y_phase_inc, size_t n_channels, size_t n_samples) {
static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state * const *BW_RESTRICT state, const float * const *x_mod, float * const *y, float * const *y_phase_inc, size_t n_channels, size_t n_samples) {
bw_phase_gen_update_coeffs_ctrl(coeffs);
if (y != NULL) {
if (x_mod != NULL) {
@ -476,8 +476,8 @@ public:
void reset(float phase_0 = 0.f);
void process(
const float * const *x_mod,
float **y,
float **y_phase_inc,
float * const *y,
float * const *y_phase_inc,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x_mod,
@ -525,8 +525,8 @@ inline void PhaseGen<N_CHANNELS>::reset(float phase_0) {
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::process(
const float * const *x_mod,
float **y,
float **y_phase_inc,
float * const *y,
float * const *y_phase_inc,
size_t nSamples) {
bw_phase_gen_process_multi(&coeffs, statesP, x_mod, y, y_phase_inc, N_CHANNELS, nSamples);
}

8
include/bw_phaser.h
View File

@ -139,7 +139,7 @@ static inline void bw_phaser_process(bw_phaser_coeffs *BW_RESTRICT coeffs, bw_ph
*
* #### bw_phaser_process_multi()
* ```>>> */
static inline void bw_phaser_process_multi(bw_phaser_coeffs *BW_RESTRICT coeffs, bw_phaser_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_phaser_process_multi(bw_phaser_coeffs *BW_RESTRICT coeffs, bw_phaser_state * 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
@ -263,7 +263,7 @@ static inline void bw_phaser_process(bw_phaser_coeffs *BW_RESTRICT coeffs, bw_ph
}
}
static inline void bw_phaser_process_multi(bw_phaser_coeffs *BW_RESTRICT coeffs, bw_phaser_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_phaser_process_multi(bw_phaser_coeffs *BW_RESTRICT coeffs, bw_phaser_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_phaser_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_phaser_update_coeffs_audio(coeffs);
@ -305,7 +305,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -353,7 +353,7 @@ inline void Phaser<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Phaser<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_phaser_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_pink_filt.h
View File

@ -148,7 +148,7 @@ static inline void bw_pink_filt_process(bw_pink_filt_coeffs *BW_RESTRICT coeffs,
*
* #### bw_pink_filt_process_multi()
* ```>>> */
static inline void bw_pink_filt_process_multi(bw_pink_filt_coeffs *BW_RESTRICT coeffs, bw_pink_filt_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_pink_filt_process_multi(bw_pink_filt_coeffs *BW_RESTRICT coeffs, bw_pink_filt_state * 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
@ -248,7 +248,7 @@ static inline void bw_pink_filt_process(bw_pink_filt_coeffs *BW_RESTRICT coeffs,
y[i] = bw_pink_filt_process1(coeffs, state, x[i]);
}
static inline void bw_pink_filt_process_multi(bw_pink_filt_coeffs *BW_RESTRICT coeffs, bw_pink_filt_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_pink_filt_process_multi(bw_pink_filt_coeffs *BW_RESTRICT coeffs, bw_pink_filt_state * 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_channels; i++)
bw_pink_filt_process(coeffs, state[i], x[i], y[i], n_samples);
}
@ -282,7 +282,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -329,7 +329,7 @@ inline void PinkFilt<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void PinkFilt<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_pink_filt_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_ppm.h
View File

@ -144,7 +144,7 @@ static inline void bw_ppm_process(bw_ppm_coeffs *BW_RESTRICT coeffs, bw_ppm_stat
*
* #### bw_ppm_process_multi()
* ```>>> */
static inline void bw_ppm_process_multi(bw_ppm_coeffs *BW_RESTRICT coeffs, bw_ppm_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_ppm_process_multi(bw_ppm_coeffs *BW_RESTRICT coeffs, bw_ppm_state * 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
@ -242,7 +242,7 @@ static inline void bw_ppm_process(bw_ppm_coeffs *BW_RESTRICT coeffs, bw_ppm_stat
}
}
static inline void bw_ppm_process_multi(bw_ppm_coeffs *BW_RESTRICT coeffs, bw_ppm_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_ppm_process_multi(bw_ppm_coeffs *BW_RESTRICT coeffs, bw_ppm_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_ppm_update_coeffs_ctrl(coeffs);
if (y != NULL)
for (size_t i = 0; i < n_samples; i++) {
@ -290,7 +290,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -338,7 +338,7 @@ inline void PPM<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void PPM<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_ppm_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

26
include/bw_reverb.h
View File

@ -147,20 +147,20 @@ static inline void bw_reverb_process1(const bw_reverb_coeffs *BW_RESTRICT coeffs
* ```>>> */
static inline void bw_reverb_process(bw_reverb_coeffs *BW_RESTRICT coeffs, bw_reverb_state *BW_RESTRICT state, const float *x_l, const float *x_r, float *y_l, float *y_r, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the input buffers `xl` (left) and `xr`
* (right) and fills the first `n_samples` of the output buffers `yl` (left)
* and `yr` (right), while using and updating both `coeffs` and `state`
* (control and audio rate).
* Processes the first `n_samples` of the input buffers `x_l` (left) and
* `x_r` (right) and fills the first `n_samples` of the output buffers `y_l`
* (left) and `y_r` (right), while using and updating both `coeffs` and
* `state` (control and audio rate).
*
* #### bw_reverb_process_multi()
* ```>>> */
static inline void bw_reverb_process_multi(bw_reverb_coeffs *BW_RESTRICT coeffs, bw_reverb_state * const *BW_RESTRICT state, const float * const *x_l, const float * const *x_r, float **yl, float **yr, size_t n_channels, size_t n_samples);
static inline void bw_reverb_process_multi(bw_reverb_coeffs *BW_RESTRICT coeffs, bw_reverb_state * const *BW_RESTRICT state, const float * const *x_l, const float * const *x_r, float * const *y_l, float * const *y_r, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x_l`
* (left) and `x_r` (right) and fills the first `n_samples` of the
* `n_channels` output buffers `y_l` (left) and `y_r` (right), while using and
* updating both the common `coeffs` and each of the `n_channels` `state`s
* (control and audio rate).
* `n_channels` output buffers `y_l` (left) and `y_r` (right), while using
* and updating both the common `coeffs` and each of the `n_channels`
* `state`s (control and audio rate).
*
* #### bw_reverb_set_predelay()
* ```>>> */
@ -591,7 +591,7 @@ static inline void bw_reverb_process(bw_reverb_coeffs *BW_RESTRICT coeffs, bw_re
}
}
static inline void bw_reverb_process_multi(bw_reverb_coeffs *BW_RESTRICT coeffs, bw_reverb_state * const *BW_RESTRICT state, const float * const *x_l, const float * const *x_r, float **y_l, float **y_r, size_t n_channels, size_t n_samples) {
static inline void bw_reverb_process_multi(bw_reverb_coeffs *BW_RESTRICT coeffs, bw_reverb_state * const *BW_RESTRICT state, const float * const *x_l, const float * const *x_r, float * const *y_l, float * const *y_r, size_t n_channels, size_t n_samples) {
bw_reverb_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_reverb_update_coeffs_audio(coeffs);
@ -643,8 +643,8 @@ public:
void process(
const float * const *x_l,
const float * const *x_r,
float **y_l,
float **y_r,
float * const *y_l,
float * const *y_r,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x_l,
@ -712,8 +712,8 @@ template<size_t N_CHANNELS>
inline void Reverb<N_CHANNELS>::process(
const float * const *x_l,
const float * const *x_r,
float **y_l,
float **y_r,
float * const *y_l,
float * const *y_r,
size_t nSamples) {
bw_reverb_process_multi(&coeffs, statesP, x_l, x_r, y_l, y_r, N_CHANNELS, nSamples);
}

8
include/bw_ringmod.h
View File

@ -126,7 +126,7 @@ static inline void bw_ringmod_process(bw_ringmod_coeffs *BW_RESTRICT coeffs, con
*
* #### bw_ringmod_process_multi()
* ```>>> */
static inline void bw_ringmod_process_multi(bw_ringmod_coeffs *BW_RESTRICT coeffs, const float * const *x_mod, const float * const *x_car, float **y, size_t n_channels, size_t n_samples);
static inline void bw_ringmod_process_multi(bw_ringmod_coeffs *BW_RESTRICT coeffs, const float * const *x_mod, const float * const *x_car, float * const *y, size_t n_channels, size_t n_samples);
/*! <<<```
* Processes the first `n_samples` of the `n_channels` modulation input
* buffers `x_mod` and of the `n_channels` carrier input buffers `x_car`, and
@ -204,7 +204,7 @@ static inline void bw_ringmod_process(bw_ringmod_coeffs *BW_RESTRICT coeffs, con
}
}
static inline void bw_ringmod_process_multi(bw_ringmod_coeffs *BW_RESTRICT coeffs, const float * const *x_mod, const float * const *x_car, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_ringmod_process_multi(bw_ringmod_coeffs *BW_RESTRICT coeffs, const float * const *x_mod, const float * const *x_car, float * const *y, size_t n_channels, size_t n_samples) {
for (size_t i = 0; i < n_samples; i++) {
bw_ringmod_update_coeffs_audio(coeffs);
for (size_t j = 0; j < n_channels; j++)
@ -238,7 +238,7 @@ public:
void process(
const float * const *x_mod,
const float * const *x_car,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x_mod,
@ -280,7 +280,7 @@ template<size_t N_CHANNELS>
inline void RingMod<N_CHANNELS>::process(
const float * const *x_mod,
const float * const *x_car,
float **y,
float * const *y,
size_t nSamples) {
bw_ringmod_process_multi(&coeffs, x_mod, x_car, y, N_CHANNELS, nSamples);
}

8
include/bw_satur.h
View File

@ -158,7 +158,7 @@ static inline void bw_satur_process(bw_satur_coeffs *BW_RESTRICT coeffs, bw_satu
*
* #### bw_satur_process_multi()
* ```>>> */
static inline void bw_satur_process_multi(bw_satur_coeffs *BW_RESTRICT coeffs, bw_satur_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_satur_process_multi(bw_satur_coeffs *BW_RESTRICT coeffs, bw_satur_state * 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
@ -312,7 +312,7 @@ static inline void bw_satur_process(bw_satur_coeffs *BW_RESTRICT coeffs, bw_satu
}
}
static inline void bw_satur_process_multi(bw_satur_coeffs *BW_RESTRICT coeffs, bw_satur_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_satur_process_multi(bw_satur_coeffs *BW_RESTRICT coeffs, bw_satur_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_satur_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_satur_update_coeffs_audio(coeffs);
@ -354,7 +354,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -402,7 +402,7 @@ inline void Satur<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Satur<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_satur_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_slew_lim.h
View File

@ -157,7 +157,7 @@ static inline void bw_slew_lim_process(bw_slew_lim_coeffs *BW_RESTRICT coeffs, b
*
* #### bw_slew_lim_process_multi()
* ```>>> */
static inline void bw_slew_lim_process_multi(bw_slew_lim_coeffs *BW_RESTRICT coeffs, bw_slew_lim_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_slew_lim_process_multi(bw_slew_lim_coeffs *BW_RESTRICT coeffs, bw_slew_lim_state * 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
@ -327,7 +327,7 @@ static inline void bw_slew_lim_process(bw_slew_lim_coeffs *BW_RESTRICT coeffs, b
}
}
static inline void bw_slew_lim_process_multi(bw_slew_lim_coeffs *BW_RESTRICT coeffs, bw_slew_lim_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_slew_lim_process_multi(bw_slew_lim_coeffs *BW_RESTRICT coeffs, bw_slew_lim_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_slew_lim_update_coeffs_ctrl(coeffs);
if (y != NULL) {
if (coeffs->max_rate_up != INFINITY) {
@ -423,7 +423,7 @@ public:
void reset(float y_z1 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -473,7 +473,7 @@ inline void SlewLim<N_CHANNELS>::reset(float y_z1) {
template<size_t N_CHANNELS>
inline void SlewLim<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_slew_lim_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_sr_reduce.h
View File

@ -120,7 +120,7 @@ static inline void bw_sr_reduce_process(bw_sr_reduce_coeffs *BW_RESTRICT coeffs,
*
* #### bw_sr_reduce_process_multi()
* ```>>> */
static inline void bw_sr_reduce_process_multi(bw_sr_reduce_coeffs *BW_RESTRICT coeffs, bw_sr_reduce_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_sr_reduce_process_multi(bw_sr_reduce_coeffs *BW_RESTRICT coeffs, bw_sr_reduce_state * 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
@ -186,7 +186,7 @@ static inline void bw_sr_reduce_process(bw_sr_reduce_coeffs *BW_RESTRICT coeffs,
y[i] = bw_sr_reduce_process1(coeffs, state, x[i]);
}
static inline void bw_sr_reduce_process_multi(bw_sr_reduce_coeffs *BW_RESTRICT coeffs, bw_sr_reduce_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_sr_reduce_process_multi(bw_sr_reduce_coeffs *BW_RESTRICT coeffs, bw_sr_reduce_state * 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_channels; i++)
bw_sr_reduce_process(coeffs, state[i], x[i], y[i], n_samples);
}
@ -215,7 +215,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -255,7 +255,7 @@ inline void SRReduce<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void SRReduce<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_sr_reduce_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

22
include/bw_src.h
View File

@ -34,10 +34,11 @@
* to count samples and channels.</li>
* <li>Added more <code>const</code> specifiers to input
* arguments.</li>
* <li>Moved C++ code to C header.</li>
* <li>Moved C++ code to C header and fixed C++ API.</li>
* <li>Added overladed C++ <code>process()</code> function taking
* C-style arrays as arguments.</li>
* <li>Removed usage of reserved identifiers.</li>
* <li>Removed useless computation when upsampling.</li>
* </ul>
* </li>
* <li>Version <strong>0.6.0</strong>:
@ -113,7 +114,7 @@ static inline void bw_src_process(const bw_src_coeffs *BW_RESTRICT coeffs, bw_sr
*
* #### bw_src_process_multi()
* ```>>> */
static inline void bw_src_process_multi(const bw_src_coeffs *BW_RESTRICT coeffs, bw_src_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t **n_in_samples, size_t **n_out_samples);
static inline void bw_src_process_multi(const bw_src_coeffs *BW_RESTRICT coeffs, bw_src_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t *n_in_samples, size_t *n_out_samples);
/*! <<<```
* Processes at most the first `n_in_samples[i]` of each input buffer `x[i]`
* and fills the corresponding output buffer `y[i]` with at most
@ -245,7 +246,6 @@ static inline void bw_src_process(const bw_src_coeffs *BW_RESTRICT coeffs, bw_sr
// TDF-II
const float v0 = coeffs->b0 * o;
const float v1 = coeffs->b1 * o;
const float v2 = coeffs->b2 * o;
y[j] = v0 + state->z1;
state->z1 = v1 - coeffs->a1 * y[j] + state->z2;
state->z2 = coeffs->b2 * o - coeffs->a2 * y[j] + state->z3;
@ -267,9 +267,9 @@ static inline void bw_src_process(const bw_src_coeffs *BW_RESTRICT coeffs, bw_sr
*n_out_samples = j;
}
static inline void bw_src_process_multi(const bw_src_coeffs *BW_RESTRICT coeffs, bw_src_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t **n_in_samples, size_t **n_out_samples) {
static inline void bw_src_process_multi(const bw_src_coeffs *BW_RESTRICT coeffs, bw_src_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t *n_in_samples, size_t *n_out_samples) {
for (size_t i = 0; i < n_channels; i++)
bw_src_process(coeffs, state[i], x[i], y[i], n_in_samples[i], n_out_samples[i]);
bw_src_process(coeffs, state[i], x[i], y[i], n_in_samples + i, n_out_samples + i);
}
#ifdef __cplusplus
@ -292,14 +292,14 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
float * const *y,
size_t *nInSamples,
size_t *nOutSamples);
void process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y,
std::array<size_t *, N_CHANNELS> nInSamples,
std::array<size_t *, N_CHANNELS> nOutSamples);
std::array<size_t, N_CHANNELS> &nInSamples,
std::array<size_t, N_CHANNELS> &nOutSamples);
/*! <<<...
* }
* ```
@ -332,7 +332,7 @@ inline void SRC<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void SRC<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t *nInSamples,
size_t *nOutSamples) {
bw_src_process_multi(coeffs, statesP, x, y, N_CHANNELS, nInSamples, nOutSamples);
@ -342,8 +342,8 @@ template<size_t N_CHANNELS>
inline void SRC<N_CHANNELS>::process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y,
std::array<size_t *, N_CHANNELS> nInSamples,
std::array<size_t *, N_CHANNELS> nOutSamples) {
std::array<size_t, N_CHANNELS> &nInSamples,
std::array<size_t, N_CHANNELS> &nOutSamples) {
process(x.data(), y.data(), nInSamples.data(), nOutSamples.data());
}

14
include/bw_src_int.h
View File

@ -122,7 +122,7 @@ static inline size_t bw_src_int_process(const bw_src_int_coeffs *BW_RESTRICT coe
*
* #### bw_src_int_process_multi()
* ```>>> */
static inline void bw_src_int_process_multi(const bw_src_int_coeffs *BW_RESTRICT coeffs, bw_src_int_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t *n, size_t n_channels, size_t n_in_samples);
static inline void bw_src_int_process_multi(const bw_src_int_coeffs *BW_RESTRICT coeffs, bw_src_int_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t *n, size_t n_channels, size_t n_in_samples);
/*! <<<```
* Processes the first `n_in_samples` of the `n_channels` input buffers `x`
* and fills the `n_channels` output buffers `y` using `coeffs`, while using
@ -240,7 +240,7 @@ static inline size_t bw_src_int_process(const bw_src_int_coeffs *BW_RESTRICT coe
return n;
}
static inline void bw_src_int_process_multi(const bw_src_int_coeffs *BW_RESTRICT coeffs, bw_src_int_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t *n, size_t n_channels, size_t n_in_samples) {
static inline void bw_src_int_process_multi(const bw_src_int_coeffs *BW_RESTRICT coeffs, bw_src_int_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t *n, size_t n_channels, size_t n_in_samples) {
if (n != NULL)
for (size_t i = 0; i < n_channels; i++)
n[i] = bw_src_int_process(coeffs, state[i], x[i], y[i], n_in_samples);
@ -266,10 +266,10 @@ class SRCInt {
public:
SRCInt(int ratio);
void reset(float x0 = 0.f);
void reset(float x_0 = 0.f);
std::array<size_t, N_CHANNELS> process(
const float * const *x,
float **y,
float * const *y,
size_t nInSamples);
std::array<size_t, N_CHANNELS> process(
std::array<const float *, N_CHANNELS> x,
@ -299,15 +299,15 @@ inline SRCInt<N_CHANNELS>::SRCInt(int ratio) {
}
template<size_t N_CHANNELS>
inline void SRCInt<N_CHANNELS>::reset(float x0) {
inline void SRCInt<N_CHANNELS>::reset(float x_0) {
for (size_t i = 0; i < N_CHANNELS; i++)
bw_src_int_reset_state(&coeffs, states + i, x0);
bw_src_int_reset_state(&coeffs, states + i, x_0);
}
template<size_t N_CHANNELS>
inline std::array<size_t, N_CHANNELS> SRCInt<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nInSamples) {
std::array<size_t, N_CHANNELS> ret;
bw_src_int_process_multi(&coeffs, statesP, x, y, ret.data(), N_CHANNELS, nInSamples);

16
include/bw_svf.h
View File

@ -164,7 +164,7 @@ static inline void bw_svf_process(bw_svf_coeffs *BW_RESTRICT coeffs, bw_svf_stat
*
* #### bw_svf_process_multi()
* ```>>> */
static inline void bw_svf_process_multi(bw_svf_coeffs *BW_RESTRICT coeffs, bw_svf_state * const *BW_RESTRICT state, const float * const *x, float **y_lp, float **y_bp, float **y_hp, size_t n_channels, size_t n_samples);
static inline void bw_svf_process_multi(bw_svf_coeffs *BW_RESTRICT coeffs, bw_svf_state * const *BW_RESTRICT state, const float * const *x, float * const *y_lp, float * const *y_bp, float * const *y_hp, 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_lp`
@ -404,7 +404,7 @@ static inline void bw_svf_process(bw_svf_coeffs *BW_RESTRICT coeffs, bw_svf_stat
}
}
static inline void bw_svf_process_multi(bw_svf_coeffs *BW_RESTRICT coeffs, bw_svf_state * const *BW_RESTRICT state, const float * const *x, float **y_lp, float **y_bp, float **y_hp, size_t n_channels, size_t n_samples) {
static inline void bw_svf_process_multi(bw_svf_coeffs *BW_RESTRICT coeffs, bw_svf_state * const *BW_RESTRICT state, const float * const *x, float * const *y_lp, float * const *y_bp, float * const *y_hp, size_t n_channels, size_t n_samples) {
if (y_lp != NULL) {
if (y_bp != NULL) {
if (y_hp != NULL) {
@ -545,9 +545,9 @@ public:
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y_lp,
float **y_bp,
float **y_hp,
float * const *y_lp,
float * const *y_bp,
float * const *y_hp,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -598,9 +598,9 @@ inline void SVF<N_CHANNELS>::reset(float x_0) {
template<size_t N_CHANNELS>
inline void SVF<N_CHANNELS>::process(
const float * const *x,
float **y_lp,
float **y_bp,
float **y_hp,
float * const *y_lp,
float * const *y_bp,
float * const *y_hp,
size_t nSamples) {
bw_svf_process_multi(&coeffs, statesP, x, y_lp, y_bp, y_hp, N_CHANNELS, nSamples);
}

8
include/bw_trem.h
View File

@ -137,7 +137,7 @@ static inline void bw_trem_process(bw_trem_coeffs *BW_RESTRICT coeffs, bw_trem_s
*
* #### bw_trem_process_multi()
* ```>>> */
static inline void bw_trem_process_multi(bw_trem_coeffs *BW_RESTRICT coeffs, bw_trem_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_trem_process_multi(bw_trem_coeffs *BW_RESTRICT coeffs, bw_trem_state * 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
@ -233,7 +233,7 @@ static inline void bw_trem_process(bw_trem_coeffs *BW_RESTRICT coeffs, bw_trem_s
}
}
static inline void bw_trem_process_multi(bw_trem_coeffs *BW_RESTRICT coeffs, bw_trem_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_trem_process_multi(bw_trem_coeffs *BW_RESTRICT coeffs, bw_trem_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_trem_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_trem_update_coeffs_audio(coeffs);
@ -271,7 +271,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -318,7 +318,7 @@ inline void Trem<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Trem<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_trem_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}

8
include/bw_wah.h
View File

@ -151,7 +151,7 @@ static inline void bw_wah_process(bw_wah_coeffs *BW_RESTRICT coeffs, bw_wah_stat
*
* #### bw_wah_process_multi()
* ```>>> */
static inline void bw_wah_process_multi(bw_wah_coeffs *BW_RESTRICT coeffs, bw_wah_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples);
static inline void bw_wah_process_multi(bw_wah_coeffs *BW_RESTRICT coeffs, bw_wah_state * 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
@ -233,7 +233,7 @@ static inline void bw_wah_process(bw_wah_coeffs *BW_RESTRICT coeffs, bw_wah_stat
}
}
static inline void bw_wah_process_multi(bw_wah_coeffs *BW_RESTRICT coeffs, bw_wah_state * const *BW_RESTRICT state, const float * const *x, float **y, size_t n_channels, size_t n_samples) {
static inline void bw_wah_process_multi(bw_wah_coeffs *BW_RESTRICT coeffs, bw_wah_state * const *BW_RESTRICT state, const float * const *x, float * const *y, size_t n_channels, size_t n_samples) {
bw_wah_update_coeffs_ctrl(coeffs);
for (size_t i = 0; i < n_samples; i++) {
bw_wah_update_coeffs_audio(coeffs);
@ -267,7 +267,7 @@ public:
void reset();
void process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
@ -313,7 +313,7 @@ inline void Wah<N_CHANNELS>::reset() {
template<size_t N_CHANNELS>
inline void Wah<N_CHANNELS>::process(
const float * const *x,
float **y,
float * const *y,
size_t nSamples) {
bw_wah_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}