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

polished bw_{pan,peak,phase_gen} + removed corresponding bwpp + fixed

Browse Source 
examples
This commit is contained in:
Stefano D'Angelo 2023-08-13 06:36:35 +02:00
parent 40503b7cb1
commit f55a9a146b
12 changed files with 413 additions and 420 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/fxpp_eq_3band/src/bw_example_fxpp_eq_3band.h
View File

@ -25,7 +25,7 @@
#include <bw_ls2.h> #include <bw_ls2.h>
#include <bw_hs2.h> #include <bw_hs2.h>
#include <bwpp_peak.h> #include <bw_peak.h>
using namespace Brickworks; using namespace Brickworks;

2
examples/fxpp_pan/src/bw_example_fxpp_pan.h
View File

@ -23,7 +23,7 @@
#include "platform.h" #include "platform.h"
#include <bwpp_pan.h> #include <bw_pan.h>
#include <bwpp_ppm.h> #include <bwpp_ppm.h>
using namespace Brickworks; using namespace Brickworks;

2
examples/synthpp_mono/src/bw_example_synthpp_mono.h
View File

@ -23,7 +23,7 @@
#include "platform.h" #include "platform.h"
#include <bwpp_phase_gen.h> #include <bw_phase_gen.h>
#include <bw_osc_saw.h> #include <bw_osc_saw.h>
#include <bw_osc_pulse.h> #include <bw_osc_pulse.h>
#include <bw_osc_tri.h> #include <bw_osc_tri.h>

2
examples/synthpp_poly/src/bw_example_synthpp_poly.h
View File

@ -24,7 +24,7 @@
#include "platform.h" #include "platform.h"
#include <bw_note_queue.h> #include <bw_note_queue.h>
#include <bwpp_phase_gen.h> #include <bw_phase_gen.h>
#include <bw_osc_saw.h> #include <bw_osc_saw.h>
#include <bw_osc_pulse.h> #include <bw_osc_pulse.h>
#include <bw_osc_tri.h> #include <bw_osc_tri.h>

2
examples/synthpp_simple/src/bw_example_synthpp_simple.h
View File

@ -23,7 +23,7 @@
#include "platform.h" #include "platform.h"
#include <bwpp_phase_gen.h> #include <bw_phase_gen.h>
#include <bw_osc_pulse.h> #include <bw_osc_pulse.h>
#include <bw_osc_filt.h> #include <bw_osc_filt.h>
#include <bwpp_svf.h> #include <bwpp_svf.h>

4
include/bw_notch.h
View File

@ -307,10 +307,10 @@ inline void Notch<N_CHANNELS>::setSampleRate(float sampleRate) {
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>
inline void Notch<N_CHANNELS>::reset(float x0) { inline void Notch<N_CHANNELS>::reset(float x_0) {
bw_notch_reset_coeffs(&coeffs); bw_notch_reset_coeffs(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++) for (size_t i = 0; i < N_CHANNELS; i++)
bw_notch_reset_state(&coeffs, states + i, x0); bw_notch_reset_state(&coeffs, states + i, x_0);
} }
template<size_t N_CHANNELS> template<size_t N_CHANNELS>

128
include/bw_pan.h
View File

@ -29,8 +29,16 @@
* <ul> * <ul>
* <li>Version <strong>1.0.0</strong>: * <li>Version <strong>1.0.0</strong>:
* <ul> * <ul>
* <li>Now using <code>size_t</code> instead of * <li>Now using parabolic curves instead of trigonometric ones.</li>
* <code>BW_SIZE_T</code>.</li> * <li><code>bw_pan_process()</code> and
* <code>bw_pan_process_multi()</code> now use <code>size_t</code>
* 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>Added overladed C++ <code>process()</code> function taking
* C-style arrays as arguments.</li>
* <li>Removed usage of reserved identifiers.</li>
* </ul> * </ul>
* </li> * </li>
* <li>Version <strong>0.6.0</strong>: * <li>Version <strong>0.6.0</strong>:
@ -55,8 +63,8 @@
* }}} * }}}
*/ */
#ifndef _BW_PAN_H #ifndef BW_PAN_H
#define _BW_PAN_H #define BW_PAN_H
#include <bw_common.h> #include <bw_common.h>
@ -67,7 +75,7 @@ extern "C" {
/*! api {{{ /*! api {{{
* #### bw_pan_coeffs * #### bw_pan_coeffs
* ```>>> */ * ```>>> */
typedef struct _bw_pan_coeffs bw_pan_coeffs; typedef struct bw_pan_coeffs bw_pan_coeffs;
/*! <<<``` /*! <<<```
* Coefficients and related. * Coefficients and related.
* *
@ -111,7 +119,7 @@ static inline void bw_pan_process1(const bw_pan_coeffs *BW_RESTRICT coeffs, floa
* *
* #### bw_pan_process() * #### bw_pan_process()
* ```>>> */ * ```>>> */
static inline void bw_pan_process(bw_pan_coeffs *BW_RESTRICT coeffs, const float *x, float *y_l, float *y_r, int n_samples); static inline void bw_pan_process(bw_pan_coeffs *BW_RESTRICT coeffs, const float *x, float *y_l, float *y_r, size_t n_samples);
/*! <<<``` /*! <<<```
* Processes the first `n_samples` of the input buffer `x` and fills the * Processes the first `n_samples` of the input buffer `x` and fills the
* first `n_samples` of the output buffers `y_l` (left) and `y_r` (right), * first `n_samples` of the output buffers `y_l` (left) and `y_r` (right),
@ -119,7 +127,7 @@ static inline void bw_pan_process(bw_pan_coeffs *BW_RESTRICT coeffs, const float
* *
* #### bw_pan_process_multi() * #### bw_pan_process_multi()
* ```>>> */ * ```>>> */
static inline void bw_pan_process_multi(bw_pan_coeffs *BW_RESTRICT coeffs, const float **x, float **y_l, float **y_r, int n_channels, int n_samples); 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);
/*! <<<``` /*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x` and * 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` * fills the first `n_samples` of the `n_channels` output buffers `y_l`
@ -152,7 +160,7 @@ static inline void bw_pan_set_pan(bw_pan_coeffs *BW_RESTRICT coeffs, float value
extern "C" { extern "C" {
#endif #endif
struct _bw_pan_coeffs { struct bw_pan_coeffs {
// Sub-components // Sub-components
bw_gain_coeffs l_coeffs; bw_gain_coeffs l_coeffs;
bw_gain_coeffs r_coeffs; bw_gain_coeffs r_coeffs;
@ -173,23 +181,23 @@ static inline void bw_pan_set_sample_rate(bw_pan_coeffs *BW_RESTRICT coeffs, flo
bw_gain_set_sample_rate(&coeffs->r_coeffs, sample_rate); bw_gain_set_sample_rate(&coeffs->r_coeffs, sample_rate);
} }
static inline void _bw_pan_do_update_coeffs(bw_pan_coeffs *BW_RESTRICT coeffs, char force) { static inline void bw_pan_do_update_coeffs(bw_pan_coeffs *BW_RESTRICT coeffs, char force) {
if (force || coeffs->pan != coeffs->pan_prev) { if (force || coeffs->pan != coeffs->pan_prev) {
const float k = 0.125f * coeffs->pan + 0.125f; const float l = 0.7071067811865477f + coeffs->pan * (-0.5f + coeffs->pan * -0.20710678118654768f);
bw_gain_set_gain_lin(&coeffs->l_coeffs, bw_cos2pif(k)); bw_gain_set_gain_lin(&coeffs->l_coeffs, l);
bw_gain_set_gain_lin(&coeffs->r_coeffs, bw_sin2pif(k)); bw_gain_set_gain_lin(&coeffs->r_coeffs, l + coeffs->pan);
coeffs->pan_prev = coeffs->pan; coeffs->pan_prev = coeffs->pan;
} }
} }
static inline void bw_pan_reset_coeffs(bw_pan_coeffs *BW_RESTRICT coeffs) { static inline void bw_pan_reset_coeffs(bw_pan_coeffs *BW_RESTRICT coeffs) {
_bw_pan_do_update_coeffs(coeffs, 1); bw_pan_do_update_coeffs(coeffs, 1);
bw_gain_reset_coeffs(&coeffs->l_coeffs); bw_gain_reset_coeffs(&coeffs->l_coeffs);
bw_gain_reset_coeffs(&coeffs->r_coeffs); bw_gain_reset_coeffs(&coeffs->r_coeffs);
} }
static inline void bw_pan_update_coeffs_ctrl(bw_pan_coeffs *BW_RESTRICT coeffs) { static inline void bw_pan_update_coeffs_ctrl(bw_pan_coeffs *BW_RESTRICT coeffs) {
_bw_pan_do_update_coeffs(coeffs, 0); bw_pan_do_update_coeffs(coeffs, 0);
bw_gain_update_coeffs_ctrl(&coeffs->l_coeffs); bw_gain_update_coeffs_ctrl(&coeffs->l_coeffs);
bw_gain_update_coeffs_ctrl(&coeffs->r_coeffs); bw_gain_update_coeffs_ctrl(&coeffs->r_coeffs);
} }
@ -204,19 +212,19 @@ static inline void bw_pan_process1(const bw_pan_coeffs *BW_RESTRICT coeffs, floa
*y_r = bw_gain_process1(&coeffs->r_coeffs, x); *y_r = bw_gain_process1(&coeffs->r_coeffs, x);
} }
static inline void bw_pan_process(bw_pan_coeffs *BW_RESTRICT coeffs, const float *x, float *y_l, float *y_r, int n_samples) { static inline void bw_pan_process(bw_pan_coeffs *BW_RESTRICT coeffs, const float *x, float *y_l, float *y_r, size_t n_samples) {
bw_pan_update_coeffs_ctrl(coeffs); bw_pan_update_coeffs_ctrl(coeffs);
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_pan_update_coeffs_audio(coeffs); bw_pan_update_coeffs_audio(coeffs);
bw_pan_process1(coeffs, x[i], y_l + i, y_r + i); bw_pan_process1(coeffs, x[i], y_l + i, y_r + i);
} }
} }
static inline void bw_pan_process_multi(bw_pan_coeffs *BW_RESTRICT coeffs, const float **x, float **y_l, float **y_r, int n_channels, int n_samples) { 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) {
bw_pan_update_coeffs_ctrl(coeffs); bw_pan_update_coeffs_ctrl(coeffs);
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_pan_update_coeffs_audio(coeffs); bw_pan_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) for (size_t j = 0; j < n_channels; j++)
bw_pan_process1(coeffs, x[j][i], y_l[j] + i, y_r[j] + i); bw_pan_process1(coeffs, x[j][i], y_l[j] + i, y_r[j] + i);
} }
} }
@ -226,6 +234,88 @@ static inline void bw_pan_set_pan(bw_pan_coeffs *BW_RESTRICT coeffs, float value
} }
#ifdef __cplusplus #ifdef __cplusplus
}
#include <array>
namespace Brickworks {
/*** Public C++ API ***/
/*! api_cpp {{{
* ##### Brickworks::Pan
* ```>>> */
template<size_t N_CHANNELS>
class Pan {
public:
Pan();
void setSampleRate(float sampleRate);
void reset();
void process(
const float * const *x,
float **y_l,
float **y_r,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y_l,
std::array<float *, N_CHANNELS> y_r,
size_t nSamples);
void setPan(float value);
/*! <<<...
* }
* ```
* }}} */
/*** Implementation ***/
/* WARNING: This part of the file is not part of the public API. Its content may
* change at any time in future versions. Please, do not use it directly. */
private:
bw_pan_coeffs coeffs;
};
template<size_t N_CHANNELS>
inline Pan<N_CHANNELS>::Pan() {
bw_pan_init(&coeffs);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::setSampleRate(float sampleRate) {
bw_pan_set_sample_rate(&coeffs, sampleRate);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::reset() {
bw_pan_reset_coeffs(&coeffs);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::process(
const float * const *x,
float **y_l,
float **y_r,
size_t nSamples) {
bw_pan_process_multi(&coeffs, x, y_l, y_r, N_CHANNELS, nSamples);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y_l,
std::array<float *, N_CHANNELS> y_r,
size_t nSamples) {
process(x.data(), y_l.data(), y_r.data(), nSamples);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::setPan(float value) {
bw_pan_set_pan(&coeffs, value);
}
} }
#endif #endif

193
include/bw_peak.h
View File

@ -37,8 +37,15 @@
* <ul> * <ul>
* <li>Version <strong>1.0.0</strong>: * <li>Version <strong>1.0.0</strong>:
* <ul> * <ul>
* <li>Now using <code>size_t</code> instead of * <li><code>bw_peak_process()</code> and
* <code>BW_SIZE_T</code>.</li> * <code>bw_peak_process_multi()</code> now use <code>size_t</code>
* 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>Added overladed C++ <code>process()</code> function taking
* C-style arrays as arguments.</li>
* <li>Removed usage of reserved identifiers.</li>
* </ul> * </ul>
* </li> * </li>
* <li>Version <strong>0.6.0</strong>: * <li>Version <strong>0.6.0</strong>:
@ -69,8 +76,8 @@
* }}} * }}}
*/ */
#ifndef _BW_PEAK_H #ifndef BW_PEAK_H
#define _BW_PEAK_H #define BW_PEAK_H
#include <bw_common.h> #include <bw_common.h>
@ -81,13 +88,13 @@ extern "C" {
/*! api {{{ /*! api {{{
* #### bw_peak_coeffs * #### bw_peak_coeffs
* ```>>> */ * ```>>> */
typedef struct _bw_peak_coeffs bw_peak_coeffs; typedef struct bw_peak_coeffs bw_peak_coeffs;
/*! <<<``` /*! <<<```
* Coefficients and related. * Coefficients and related.
* *
* #### bw_peak_state * #### bw_peak_state
* ```>>> */ * ```>>> */
typedef struct _bw_peak_state bw_peak_state; typedef struct bw_peak_state bw_peak_state;
/*! <<<``` /*! <<<```
* Internal state and related. * Internal state and related.
* *
@ -111,10 +118,10 @@ static inline void bw_peak_reset_coeffs(bw_peak_coeffs *BW_RESTRICT coeffs);
* *
* #### bw_peak_reset_state() * #### bw_peak_reset_state()
* ```>>> */ * ```>>> */
static inline void bw_peak_reset_state(const bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state *BW_RESTRICT state, float x0); static inline void bw_peak_reset_state(const bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state *BW_RESTRICT state, float x_0);
/*! <<<``` /*! <<<```
* Resets the given `state` to its initial values using the given `coeffs` * Resets the given `state` to its initial values using the given `coeffs`
* and the quiescent/initial input value `x0`. * and the quiescent/initial input value `x_0`.
* *
* #### bw_peak_update_coeffs_ctrl() * #### bw_peak_update_coeffs_ctrl()
* ```>>> */ * ```>>> */
@ -137,7 +144,7 @@ static inline float bw_peak_process1(const bw_peak_coeffs *BW_RESTRICT coeffs, b
* *
* #### bw_peak_process() * #### bw_peak_process()
* ```>>> */ * ```>>> */
static inline void bw_peak_process(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state *BW_RESTRICT state, const float *x, float *y, int n_samples); static inline void bw_peak_process(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state *BW_RESTRICT state, const float *x, float *y, size_t n_samples);
/*! <<<``` /*! <<<```
* Processes the first `n_samples` of the input buffer `x` and fills the * Processes the first `n_samples` of the input buffer `x` and fills the
* first `n_samples` of the output buffer `y`, while using and updating both * first `n_samples` of the output buffer `y`, while using and updating both
@ -145,7 +152,7 @@ static inline void bw_peak_process(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_s
* *
* #### bw_peak_process_multi() * #### bw_peak_process_multi()
* ```>>> */ * ```>>> */
static inline void bw_peak_process_multi(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state **BW_RESTRICT state, const float **x, float **y, int n_channels, int 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 **y, size_t n_channels, size_t n_samples);
/*! <<<``` /*! <<<```
* Processes the first `n_samples` of the `n_channels` input buffers `x` and * 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 * fills the first `n_samples` of the `n_channels` output buffers `y`, while
@ -221,7 +228,7 @@ static inline void bw_peak_set_use_bandwidth(bw_peak_coeffs *BW_RESTRICT coeffs,
extern "C" { extern "C" {
#endif #endif
struct _bw_peak_coeffs { struct bw_peak_coeffs {
// Sub-components // Sub-components
bw_mm2_coeffs mm2_coeffs; bw_mm2_coeffs mm2_coeffs;
@ -236,13 +243,13 @@ struct _bw_peak_coeffs {
int param_changed; int param_changed;
}; };
struct _bw_peak_state { struct bw_peak_state {
bw_mm2_state mm2_state; bw_mm2_state mm2_state;
}; };
#define _BW_PEAK_PARAM_PEAK_GAIN 1 #define BW_PEAK_PARAM_PEAK_GAIN 1
#define _BW_PEAK_PARAM_Q (1<<1) #define BW_PEAK_PARAM_Q (1<<1)
#define _BW_PEAK_PARAM_BANDWIDTH (1<<2) #define BW_PEAK_PARAM_BANDWIDTH (1<<2)
static inline void bw_peak_init(bw_peak_coeffs *BW_RESTRICT coeffs) { static inline void bw_peak_init(bw_peak_coeffs *BW_RESTRICT coeffs) {
bw_mm2_init(&coeffs->mm2_coeffs); bw_mm2_init(&coeffs->mm2_coeffs);
@ -256,19 +263,19 @@ static inline void bw_peak_set_sample_rate(bw_peak_coeffs *BW_RESTRICT coeffs, f
bw_mm2_set_sample_rate(&coeffs->mm2_coeffs, sample_rate); bw_mm2_set_sample_rate(&coeffs->mm2_coeffs, sample_rate);
} }
static inline void _bw_peak_update_mm2_params(bw_peak_coeffs *BW_RESTRICT coeffs) { static inline void bw_peak_update_mm2_params(bw_peak_coeffs *BW_RESTRICT coeffs) {
if (coeffs->param_changed) { if (coeffs->param_changed) {
if (coeffs->use_bandwidth) { if (coeffs->use_bandwidth) {
if (coeffs->param_changed & (_BW_PEAK_PARAM_PEAK_GAIN | _BW_PEAK_PARAM_BANDWIDTH)) { if (coeffs->param_changed & (BW_PEAK_PARAM_PEAK_GAIN | BW_PEAK_PARAM_BANDWIDTH)) {
if (coeffs->param_changed & _BW_PEAK_PARAM_BANDWIDTH) if (coeffs->param_changed & BW_PEAK_PARAM_BANDWIDTH)
coeffs->bw_k = bw_pow2f(coeffs->bandwidth); coeffs->bw_k = bw_pow2f(coeffs->bandwidth);
const float Q = bw_sqrtf(coeffs->bw_k * coeffs->peak_gain) * bw_rcpf(coeffs->bw_k - 1.f); const float Q = bw_sqrtf(coeffs->bw_k * coeffs->peak_gain) * bw_rcpf(coeffs->bw_k - 1.f);
bw_mm2_set_Q(&coeffs->mm2_coeffs, Q); bw_mm2_set_Q(&coeffs->mm2_coeffs, Q);
bw_mm2_set_coeff_bp(&coeffs->mm2_coeffs, (coeffs->peak_gain - 1.f) * bw_rcpf(Q)); bw_mm2_set_coeff_bp(&coeffs->mm2_coeffs, (coeffs->peak_gain - 1.f) * bw_rcpf(Q));
} }
} else { } else {
if (coeffs->param_changed & (_BW_PEAK_PARAM_PEAK_GAIN | _BW_PEAK_PARAM_Q)) { if (coeffs->param_changed & (BW_PEAK_PARAM_PEAK_GAIN | BW_PEAK_PARAM_Q)) {
if (coeffs->param_changed & _BW_PEAK_PARAM_Q) if (coeffs->param_changed & BW_PEAK_PARAM_Q)
bw_mm2_set_Q(&coeffs->mm2_coeffs, coeffs->Q); bw_mm2_set_Q(&coeffs->mm2_coeffs, coeffs->Q);
bw_mm2_set_coeff_bp(&coeffs->mm2_coeffs, (coeffs->peak_gain - 1.f) * bw_rcpf(coeffs->Q)); bw_mm2_set_coeff_bp(&coeffs->mm2_coeffs, (coeffs->peak_gain - 1.f) * bw_rcpf(coeffs->Q));
} }
@ -279,16 +286,16 @@ static inline void _bw_peak_update_mm2_params(bw_peak_coeffs *BW_RESTRICT coeffs
static inline void bw_peak_reset_coeffs(bw_peak_coeffs *BW_RESTRICT coeffs) { static inline void bw_peak_reset_coeffs(bw_peak_coeffs *BW_RESTRICT coeffs) {
coeffs->param_changed = ~0; coeffs->param_changed = ~0;
_bw_peak_update_mm2_params(coeffs); bw_peak_update_mm2_params(coeffs);
bw_mm2_reset_coeffs(&coeffs->mm2_coeffs); bw_mm2_reset_coeffs(&coeffs->mm2_coeffs);
} }
static inline void bw_peak_reset_state(const bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state *BW_RESTRICT state, float x0) { static inline void bw_peak_reset_state(const bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state *BW_RESTRICT state, float x_0) {
bw_mm2_reset_state(&coeffs->mm2_coeffs, &state->mm2_state, x0); bw_mm2_reset_state(&coeffs->mm2_coeffs, &state->mm2_state, x_0);
} }
static inline void bw_peak_update_coeffs_ctrl(bw_peak_coeffs *BW_RESTRICT coeffs) { static inline void bw_peak_update_coeffs_ctrl(bw_peak_coeffs *BW_RESTRICT coeffs) {
_bw_peak_update_mm2_params(coeffs); bw_peak_update_mm2_params(coeffs);
bw_mm2_update_coeffs_ctrl(&coeffs->mm2_coeffs); bw_mm2_update_coeffs_ctrl(&coeffs->mm2_coeffs);
} }
@ -300,19 +307,19 @@ static inline float bw_peak_process1(const bw_peak_coeffs *BW_RESTRICT coeffs, b
return bw_mm2_process1(&coeffs->mm2_coeffs, &state->mm2_state, x); return bw_mm2_process1(&coeffs->mm2_coeffs, &state->mm2_state, x);
} }
static inline void bw_peak_process(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state *BW_RESTRICT state, const float *x, float *y, int n_samples) { static inline void bw_peak_process(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state *BW_RESTRICT state, const float *x, float *y, size_t n_samples) {
bw_peak_update_coeffs_ctrl(coeffs); bw_peak_update_coeffs_ctrl(coeffs);
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_peak_update_coeffs_audio(coeffs); bw_peak_update_coeffs_audio(coeffs);
y[i] = bw_peak_process1(coeffs, state, x[i]); y[i] = bw_peak_process1(coeffs, state, x[i]);
} }
} }
static inline void bw_peak_process_multi(bw_peak_coeffs *BW_RESTRICT coeffs, bw_peak_state **BW_RESTRICT state, const float **x, float **y, int n_channels, int 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 **y, size_t n_channels, size_t n_samples) {
bw_peak_update_coeffs_ctrl(coeffs); bw_peak_update_coeffs_ctrl(coeffs);
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_peak_update_coeffs_audio(coeffs); bw_peak_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) for (size_t j = 0; j < n_channels; j++)
y[j][i] = bw_peak_process1(coeffs, state[j], x[j][i]); y[j][i] = bw_peak_process1(coeffs, state[j], x[j][i]);
} }
} }
@ -324,14 +331,14 @@ static inline void bw_peak_set_cutoff(bw_peak_coeffs *BW_RESTRICT coeffs, float
static inline void bw_peak_set_Q(bw_peak_coeffs *BW_RESTRICT coeffs, float value) { static inline void bw_peak_set_Q(bw_peak_coeffs *BW_RESTRICT coeffs, float value) {
if (coeffs->Q != value) { if (coeffs->Q != value) {
coeffs->Q = value; coeffs->Q = value;
coeffs->param_changed |= _BW_PEAK_PARAM_Q; coeffs->param_changed |= BW_PEAK_PARAM_Q;
} }
} }
static inline void bw_peak_set_peak_gain_lin(bw_peak_coeffs *BW_RESTRICT coeffs, float value) { static inline void bw_peak_set_peak_gain_lin(bw_peak_coeffs *BW_RESTRICT coeffs, float value) {
if (coeffs->peak_gain != value) { if (coeffs->peak_gain != value) {
coeffs->peak_gain = value; coeffs->peak_gain = value;
coeffs->param_changed |= _BW_PEAK_PARAM_PEAK_GAIN; coeffs->param_changed |= BW_PEAK_PARAM_PEAK_GAIN;
} }
} }
@ -342,22 +349,136 @@ static inline void bw_peak_set_peak_gain_dB(bw_peak_coeffs *BW_RESTRICT coeffs,
static inline void bw_peak_set_bandwidth(bw_peak_coeffs *BW_RESTRICT coeffs, float value) { static inline void bw_peak_set_bandwidth(bw_peak_coeffs *BW_RESTRICT coeffs, float value) {
if (coeffs->bandwidth != value) { if (coeffs->bandwidth != value) {
coeffs->bandwidth = value; coeffs->bandwidth = value;
coeffs->param_changed |= _BW_PEAK_PARAM_BANDWIDTH; coeffs->param_changed |= BW_PEAK_PARAM_BANDWIDTH;
} }
} }
static inline void bw_peak_set_use_bandwidth(bw_peak_coeffs *BW_RESTRICT coeffs, char value) { static inline void bw_peak_set_use_bandwidth(bw_peak_coeffs *BW_RESTRICT coeffs, char value) {
if ((coeffs->use_bandwidth && !value) || (!coeffs->use_bandwidth && value)) { if ((coeffs->use_bandwidth && !value) || (!coeffs->use_bandwidth && value)) {
coeffs->use_bandwidth = value; coeffs->use_bandwidth = value;
coeffs->param_changed |= _BW_PEAK_PARAM_Q | _BW_PEAK_PARAM_BANDWIDTH; coeffs->param_changed |= BW_PEAK_PARAM_Q | BW_PEAK_PARAM_BANDWIDTH;
} }
} }
#undef _BW_PEAK_PARAM_PEAK_GAIN #undef BW_PEAK_PARAM_PEAK_GAIN
#undef _BW_PEAK_PARAM_Q #undef BW_PEAK_PARAM_Q
#undef _BW_PEAK_PARAM_BANDWIDTH #undef BW_PEAK_PARAM_BANDWIDTH
#ifdef __cplusplus #ifdef __cplusplus
}
#include <array>
namespace Brickworks {
/*** Public C++ API ***/
/*! api_cpp {{{
* ##### Brickworks::Peak
* ```>>> */
template<size_t N_CHANNELS>
class Peak {
public:
Peak();
void setSampleRate(float sampleRate);
void reset(float x_0 = 0.f);
void process(
const float * const *x,
float **y,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y,
size_t nSamples);
void setCutoff(float value);
void setQ(float value);
void setPeakGainLin(float value);
void setPeakGainDB(float value);
void setBandwidth(float value);
void setUseBandwidth(bool value);
/*! <<<...
* }
* ```
* }}} */
/*** Implementation ***/
/* WARNING: This part of the file is not part of the public API. Its content may
* change at any time in future versions. Please, do not use it directly. */
private:
bw_peak_coeffs coeffs;
bw_peak_state states[N_CHANNELS];
bw_peak_state *statesP[N_CHANNELS];
};
template<size_t N_CHANNELS>
inline Peak<N_CHANNELS>::Peak() {
bw_peak_init(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++)
statesP[i] = states + i;
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setSampleRate(float sampleRate) {
bw_peak_set_sample_rate(&coeffs, sampleRate);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::reset(float x_0) {
bw_peak_reset_coeffs(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++)
bw_peak_reset_state(&coeffs, states + i, x_0);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::process(
const float * const *x,
float **y,
size_t nSamples) {
bw_peak_process_multi(&coeffs, statesP, x, y, N_CHANNELS, nSamples);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y,
size_t nSamples) {
process(x.data(), y.data(), nSamples);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setCutoff(float value) {
bw_peak_set_cutoff(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setQ(float value) {
bw_peak_set_Q(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setPeakGainLin(float value) {
bw_peak_set_peak_gain_lin(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setPeakGainDB(float value) {
bw_peak_set_peak_gain_dB(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setBandwidth(float value) {
bw_peak_set_bandwidth(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setUseBandwidth(bool value) {
bw_peak_set_use_bandwidth(&coeffs, value);
}
} }
#endif #endif

179
include/bw_phase_gen.h
View File

@ -31,8 +31,15 @@
* <ul> * <ul>
* <li>Version <strong>1.0.0</strong>: * <li>Version <strong>1.0.0</strong>:
* <ul> * <ul>
* <li>Now using <code>size_t</code> instead of * <li><code>bw_phase_gen_process()</code> and
* <code>BW_SIZE_T</code>.</li> * <code>bw_phase_gen_process_multi()</code> now use
* <code>size_t</code> 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>Added overladed C++ <code>process()</code> function taking
* C-style arrays as arguments.</li>
* <li>Removed usage of reserved identifiers.</li>
* </ul> * </ul>
* </li> * </li>
* <li>Version <strong>0.6.0</strong>: * <li>Version <strong>0.6.0</strong>:
@ -71,8 +78,8 @@
* }}} * }}}
*/ */
#ifndef _BW_PHASE_GEN_H #ifndef BW_PHASE_GEN_H
#define _BW_PHASE_GEN_H #define BW_PHASE_GEN_H
#include <bw_common.h> #include <bw_common.h>
@ -83,13 +90,13 @@ extern "C" {
/*! api {{{ /*! api {{{
* #### bw_phase_gen_coeffs * #### bw_phase_gen_coeffs
* ```>>> */ * ```>>> */
typedef struct _bw_phase_gen_coeffs bw_phase_gen_coeffs; typedef struct bw_phase_gen_coeffs bw_phase_gen_coeffs;
/*! <<<``` /*! <<<```
* Coefficients and related. * Coefficients and related.
* *
* #### bw_phase_gen_state * #### bw_phase_gen_state
* ```>>> */ * ```>>> */
typedef struct _bw_phase_gen_state bw_phase_gen_state; typedef struct bw_phase_gen_state bw_phase_gen_state;
/*! <<<``` /*! <<<```
* Internal state and related. * Internal state and related.
* *
@ -146,7 +153,7 @@ static inline void bw_phase_gen_process1_mod(const bw_phase_gen_coeffs *BW_RESTR
* *
* #### bw_phase_gen_process() * #### bw_phase_gen_process()
* ```>>> */ * ```>>> */
static inline void bw_phase_gen_process(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state *BW_RESTRICT state, const float *x_mod, float *y, float *y_phase_inc, int n_samples); static inline void bw_phase_gen_process(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state *BW_RESTRICT state, const float *x_mod, float *y, float *y_phase_inc, size_t n_samples);
/*! <<<``` /*! <<<```
* Generates and fills the first `n_samples` of the output buffer `y`, while * Generates and fills the first `n_samples` of the output buffer `y`, while
* using and updating both `coeffs` and `state` (control and audio rate). * using and updating both `coeffs` and `state` (control and audio rate).
@ -158,7 +165,7 @@ static inline void bw_phase_gen_process(bw_phase_gen_coeffs *BW_RESTRICT coeffs,
* *
* #### bw_phase_gen_process_multi() * #### bw_phase_gen_process_multi()
* ```>>> */ * ```>>> */
static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state **BW_RESTRICT state, const float **x_mod, float **y, float **y_phase_inc, int n_channels, int 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 **y, float **y_phase_inc, size_t n_channels, size_t n_samples);
/*! <<<``` /*! <<<```
* Generates and fills the first `n_samples` of the `n_channels` output * Generates and fills the first `n_samples` of the `n_channels` output
* buffers `y`, while using and updating both the common `coeffs` and each of * buffers `y`, while using and updating both the common `coeffs` and each of
@ -204,7 +211,7 @@ static inline void bw_phase_gen_set_portamento_tau(bw_phase_gen_coeffs *BW_RESTR
extern "C" { extern "C" {
#endif #endif
struct _bw_phase_gen_coeffs { struct bw_phase_gen_coeffs {
// Sub-components // Sub-components
bw_one_pole_coeffs portamento_coeffs; bw_one_pole_coeffs portamento_coeffs;
bw_one_pole_state portamento_state; bw_one_pole_state portamento_state;
@ -219,7 +226,7 @@ struct _bw_phase_gen_coeffs {
float frequency_prev; float frequency_prev;
}; };
struct _bw_phase_gen_state { struct bw_phase_gen_state {
float phase; float phase;
}; };
@ -233,7 +240,7 @@ static inline void bw_phase_gen_set_sample_rate(bw_phase_gen_coeffs *BW_RESTRICT
coeffs->T = 1.f / sample_rate; coeffs->T = 1.f / sample_rate;
} }
static inline void _bw_phase_gen_do_update_coeffs_ctrl(bw_phase_gen_coeffs *BW_RESTRICT coeffs, char force) { static inline void bw_phase_gen_do_update_coeffs_ctrl(bw_phase_gen_coeffs *BW_RESTRICT coeffs, char force) {
bw_one_pole_update_coeffs_ctrl(&coeffs->portamento_coeffs); bw_one_pole_update_coeffs_ctrl(&coeffs->portamento_coeffs);
if (force || coeffs->frequency != coeffs->frequency_prev) { if (force || coeffs->frequency != coeffs->frequency_prev) {
coeffs->portamento_target = coeffs->T * coeffs->frequency; coeffs->portamento_target = coeffs->T * coeffs->frequency;
@ -242,7 +249,7 @@ static inline void _bw_phase_gen_do_update_coeffs_ctrl(bw_phase_gen_coeffs *BW_R
} }
static inline void bw_phase_gen_reset_coeffs(bw_phase_gen_coeffs *BW_RESTRICT coeffs) { static inline void bw_phase_gen_reset_coeffs(bw_phase_gen_coeffs *BW_RESTRICT coeffs) {
_bw_phase_gen_do_update_coeffs_ctrl(coeffs, 1); bw_phase_gen_do_update_coeffs_ctrl(coeffs, 1);
bw_one_pole_reset_coeffs(&coeffs->portamento_coeffs); bw_one_pole_reset_coeffs(&coeffs->portamento_coeffs);
bw_one_pole_reset_state(&coeffs->portamento_coeffs, &coeffs->portamento_state, coeffs->portamento_target); bw_one_pole_reset_state(&coeffs->portamento_coeffs, &coeffs->portamento_state, coeffs->portamento_target);
} }
@ -253,7 +260,7 @@ static inline void bw_phase_gen_reset_state(const bw_phase_gen_coeffs *BW_RESTRI
} }
static inline void bw_phase_gen_update_coeffs_ctrl(bw_phase_gen_coeffs *BW_RESTRICT coeffs) { static inline void bw_phase_gen_update_coeffs_ctrl(bw_phase_gen_coeffs *BW_RESTRICT coeffs) {
_bw_phase_gen_do_update_coeffs_ctrl(coeffs, 0); bw_phase_gen_do_update_coeffs_ctrl(coeffs, 0);
} }
static inline void bw_phase_gen_update_coeffs_audio(bw_phase_gen_coeffs *BW_RESTRICT coeffs) { static inline void bw_phase_gen_update_coeffs_audio(bw_phase_gen_coeffs *BW_RESTRICT coeffs) {
@ -276,29 +283,29 @@ static inline void bw_phase_gen_process1_mod(const bw_phase_gen_coeffs *BW_RESTR
*y = _bw_phase_gen_update_phase(state, *y_phase_inc); *y = _bw_phase_gen_update_phase(state, *y_phase_inc);
} }
static inline void bw_phase_gen_process(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state *BW_RESTRICT state, const float *x_mod, float* y, float *y_phase_inc, int n_samples) { static inline void bw_phase_gen_process(bw_phase_gen_coeffs *BW_RESTRICT coeffs, bw_phase_gen_state *BW_RESTRICT state, const float *x_mod, float* y, float *y_phase_inc, size_t n_samples) {
bw_phase_gen_update_coeffs_ctrl(coeffs); bw_phase_gen_update_coeffs_ctrl(coeffs);
if (y != NULL) { if (y != NULL) {
if (x_mod != NULL) { if (x_mod != NULL) {
if (y_phase_inc != NULL) if (y_phase_inc != NULL)
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
bw_phase_gen_process1_mod(coeffs, state, x_mod[i], y + i, y_phase_inc + i); bw_phase_gen_process1_mod(coeffs, state, x_mod[i], y + i, y_phase_inc + i);
} }
else else
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
float v_phase_inc; float v_phase_inc;
bw_phase_gen_process1_mod(coeffs, state, x_mod[i], y + i, &v_phase_inc); bw_phase_gen_process1_mod(coeffs, state, x_mod[i], y + i, &v_phase_inc);
} }
} else { } else {
if (y_phase_inc != NULL) if (y_phase_inc != NULL)
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
bw_phase_gen_process1(coeffs, state, y + i, y_phase_inc + i); bw_phase_gen_process1(coeffs, state, y + i, y_phase_inc + i);
} }
else else
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
float v_phase_inc; float v_phase_inc;
bw_phase_gen_process1(coeffs, state, y + i, &v_phase_inc); bw_phase_gen_process1(coeffs, state, y + i, &v_phase_inc);
@ -307,26 +314,26 @@ static inline void bw_phase_gen_process(bw_phase_gen_coeffs *BW_RESTRICT coeffs,
} else { } else {
if (x_mod != NULL) { if (x_mod != NULL) {
if (y_phase_inc != NULL) if (y_phase_inc != NULL)
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
float v; float v;
bw_phase_gen_process1_mod(coeffs, state, x_mod[i], &v, y_phase_inc + i); bw_phase_gen_process1_mod(coeffs, state, x_mod[i], &v, y_phase_inc + i);
} }
else else
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
float v, v_phase_inc; float v, v_phase_inc;
bw_phase_gen_process1_mod(coeffs, state, x_mod[i], &v, &v_phase_inc); bw_phase_gen_process1_mod(coeffs, state, x_mod[i], &v, &v_phase_inc);
} }
} else { } else {
if (y_phase_inc != NULL) if (y_phase_inc != NULL)
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
float v; float v;
bw_phase_gen_process1(coeffs, state, &v, y_phase_inc + i); bw_phase_gen_process1(coeffs, state, &v, y_phase_inc + i);
} }
else else
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
float v, v_phase_inc; float v, v_phase_inc;
bw_phase_gen_process1(coeffs, state, &v, &v_phase_inc); bw_phase_gen_process1(coeffs, state, &v, &v_phase_inc);
@ -335,14 +342,14 @@ 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 **BW_RESTRICT state, const float **x_mod, float **y, float **y_phase_inc, int n_channels, int 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 **y, float **y_phase_inc, size_t n_channels, size_t n_samples) {
bw_phase_gen_update_coeffs_ctrl(coeffs); bw_phase_gen_update_coeffs_ctrl(coeffs);
if (y != NULL) { if (y != NULL) {
if (x_mod != NULL) { if (x_mod != NULL) {
if (y_phase_inc != NULL) if (y_phase_inc != NULL)
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) { for (size_t j = 0; j < n_channels; j++) {
float v, v_phase_inc; float v, v_phase_inc;
if (x_mod[j]) if (x_mod[j])
bw_phase_gen_process1_mod(coeffs, state[j], x_mod[j][i], &v, &v_phase_inc); bw_phase_gen_process1_mod(coeffs, state[j], x_mod[j][i], &v, &v_phase_inc);
@ -355,9 +362,9 @@ static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT c
} }
} }
else else
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) { for (size_t j = 0; j < n_channels; j++) {
float v, v_phase_inc; float v, v_phase_inc;
if (x_mod[j]) if (x_mod[j])
bw_phase_gen_process1_mod(coeffs, state[j], x_mod[j][i], &v, &v_phase_inc); bw_phase_gen_process1_mod(coeffs, state[j], x_mod[j][i], &v, &v_phase_inc);
@ -369,9 +376,9 @@ static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT c
} }
} else { } else {
if (y_phase_inc != NULL) if (y_phase_inc != NULL)
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) { for (size_t j = 0; j < n_channels; j++) {
float v, v_phase_inc; float v, v_phase_inc;
bw_phase_gen_process1(coeffs, state[j], &v, &v_phase_inc); bw_phase_gen_process1(coeffs, state[j], &v, &v_phase_inc);
if (y[j]) if (y[j])
@ -381,9 +388,9 @@ static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT c
} }
} }
else else
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) { for (size_t j = 0; j < n_channels; j++) {
float v, v_phase_inc; float v, v_phase_inc;
bw_phase_gen_process1(coeffs, state[j], &v, &v_phase_inc); bw_phase_gen_process1(coeffs, state[j], &v, &v_phase_inc);
if (y[j]) if (y[j])
@ -394,9 +401,9 @@ static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT c
} else { } else {
if (x_mod != NULL) { if (x_mod != NULL) {
if (y_phase_inc != NULL) if (y_phase_inc != NULL)
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) { for (size_t j = 0; j < n_channels; j++) {
float v, v_phase_inc; float v, v_phase_inc;
if (x_mod[j]) if (x_mod[j])
bw_phase_gen_process1_mod(coeffs, state[j], x_mod[j][i], &v, &v_phase_inc); bw_phase_gen_process1_mod(coeffs, state[j], x_mod[j][i], &v, &v_phase_inc);
@ -407,9 +414,9 @@ static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT c
} }
} }
else else
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) { for (size_t j = 0; j < n_channels; j++) {
float v, v_phase_inc; float v, v_phase_inc;
if (x_mod[j]) if (x_mod[j])
bw_phase_gen_process1_mod(coeffs, state[j], x_mod[j][i], &v, &v_phase_inc); bw_phase_gen_process1_mod(coeffs, state[j], x_mod[j][i], &v, &v_phase_inc);
@ -419,9 +426,9 @@ static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT c
} }
} else { } else {
if (y_phase_inc != NULL) if (y_phase_inc != NULL)
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) { for (size_t j = 0; j < n_channels; j++) {
float v, v_phase_inc; float v, v_phase_inc;
bw_phase_gen_process1(coeffs, state[j], &v, &v_phase_inc); bw_phase_gen_process1(coeffs, state[j], &v, &v_phase_inc);
if (y_phase_inc[j]) if (y_phase_inc[j])
@ -429,9 +436,9 @@ static inline void bw_phase_gen_process_multi(bw_phase_gen_coeffs *BW_RESTRICT c
} }
} }
else else
for (int i = 0; i < n_samples; i++) { for (size_t i = 0; i < n_samples; i++) {
bw_phase_gen_update_coeffs_audio(coeffs); bw_phase_gen_update_coeffs_audio(coeffs);
for (int j = 0; j < n_channels; j++) { for (size_t j = 0; j < n_channels; j++) {
float v, v_phase_inc; float v, v_phase_inc;
bw_phase_gen_process1(coeffs, state[j], &v, &v_phase_inc); bw_phase_gen_process1(coeffs, state[j], &v, &v_phase_inc);
} }
@ -449,6 +456,100 @@ static inline void bw_phase_gen_set_portamento_tau(bw_phase_gen_coeffs *BW_RESTR
} }
#ifdef __cplusplus #ifdef __cplusplus
}
#include <array>
namespace Brickworks {
/*** Public C++ API ***/
/*! api_cpp {{{
* ##### Brickworks::PhaseGen
* ```>>> */
template<size_t N_CHANNELS>
class PhaseGen {
public:
PhaseGen();
void setSampleRate(float sampleRate);
void reset(float phase_0 = 0.f);
void process(
const float * const *x_mod,
float **y,
float **y_phase_inc,
size_t nSamples);
void process(
std::array<const float *, N_CHANNELS> x_mod,
std::array<float *, N_CHANNELS> y,
std::array<float *, N_CHANNELS> y_phase_inc,
size_t nSamples);
void setFrequency(float value);
void setPortamentoTau(float value);
/*! <<<...
* }
* ```
* }}} */
/*** Implementation ***/
/* WARNING: This part of the file is not part of the public API. Its content may
* change at any time in future versions. Please, do not use it directly. */
private:
bw_phase_gen_coeffs coeffs;
bw_phase_gen_state states[N_CHANNELS];
bw_phase_gen_state *statesP[N_CHANNELS];
};
template<size_t N_CHANNELS>
inline PhaseGen<N_CHANNELS>::PhaseGen() {
bw_phase_gen_init(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++)
statesP[i] = states + i;
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::setSampleRate(float sampleRate) {
bw_phase_gen_set_sample_rate(&coeffs, sampleRate);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::reset(float phase_0) {
bw_phase_gen_reset_coeffs(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++)
bw_phase_gen_reset_state(&coeffs, states + i, phase_0);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::process(
const float * const *x_mod,
float **y,
float **y_phase_inc,
size_t nSamples) {
bw_phase_gen_process_multi(&coeffs, statesP, x_mod, y, y_phase_inc, N_CHANNELS, nSamples);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::process(
std::array<const float *, N_CHANNELS> x_mod,
std::array<float *, N_CHANNELS> y,
std::array<float *, N_CHANNELS> y_phase_inc,
size_t nSamples) {
process(x_mod.data(), y.data(), y_phase_inc.data(), nSamples);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::setFrequency(float value) {
bw_phase_gen_set_frequency(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::setPortamentoTau(float value) {
bw_phase_gen_set_portamento_tau(&coeffs, value);
}
} }
#endif #endif

91
include/bwpp_pan.h
View File

@ -1,91 +0,0 @@
/*
* Brickworks
*
* Copyright (C) 2023 Orastron Srl unipersonale
*
* Brickworks is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3 of the License.
*
* Brickworks is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Brickworks. If not, see <http://www.gnu.org/licenses/>.
*
* File author: Stefano D'Angelo
*/
#ifndef BWPP_PAN_H
#define BWPP_PAN_H
#include <bw_pan.h>
#include <array>
namespace Brickworks {
/*! api {{{
* ##### Brickworks::Pan
* ```>>> */
template<size_t N_CHANNELS>
class Pan {
public:
Pan();
void setSampleRate(float sampleRate);
void reset();
void process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y_l,
std::array<float *, N_CHANNELS> y_r,
int nSamples);
void setPan(float value);
/*! <<<...
* }
* ```
* }}} */
/*** Implementation ***/
/* WARNING: This part of the file is not part of the public API. Its content may
* change at any time in future versions. Please, do not use it directly. */
private:
bw_pan_coeffs coeffs;
};
template<size_t N_CHANNELS>
inline Pan<N_CHANNELS>::Pan() {
bw_pan_init(&coeffs);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::setSampleRate(float sampleRate) {
bw_pan_set_sample_rate(&coeffs, sampleRate);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::reset() {
bw_pan_reset_coeffs(&coeffs);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y_l,
std::array<float *, N_CHANNELS> y_r,
int nSamples) {
bw_pan_process_multi(&coeffs, x.data(), y_l.data(), y_r.data(), N_CHANNELS, nSamples);
}
template<size_t N_CHANNELS>
inline void Pan<N_CHANNELS>::setPan(float value) {
bw_pan_set_pan(&coeffs, value);
}
}
#endif

125
include/bwpp_peak.h
View File

@ -1,125 +0,0 @@
/*
* Brickworks
*
* Copyright (C) 2023 Orastron Srl unipersonale
*
* Brickworks is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3 of the License.
*
* Brickworks is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Brickworks. If not, see <http://www.gnu.org/licenses/>.
*
* File author: Stefano D'Angelo
*/
#ifndef BWPP_PEAK_H
#define BWPP_PEAK_H
#include <bw_peak.h>
#include <array>
namespace Brickworks {
/*! api {{{
* ##### Brickworks::Peak
* ```>>> */
template<size_t N_CHANNELS>
class Peak {
public:
Peak();
void setSampleRate(float sampleRate);
void reset(float x0 = 0.f);
void process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y,
int nSamples);
void setCutoff(float value);
void setQ(float value);
void setPeakGainLin(float value);
void setPeakGainDB(float value);
void setBandwidth(float value);
void setUseBandwidth(bool value);
/*! <<<...
* }
* ```
* }}} */
/*** Implementation ***/
/* WARNING: This part of the file is not part of the public API. Its content may
* change at any time in future versions. Please, do not use it directly. */
private:
bw_peak_coeffs coeffs;
bw_peak_state states[N_CHANNELS];
bw_peak_state *statesP[N_CHANNELS];
};
template<size_t N_CHANNELS>
inline Peak<N_CHANNELS>::Peak() {
bw_peak_init(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++)
statesP[i] = states + i;
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setSampleRate(float sampleRate) {
bw_peak_set_sample_rate(&coeffs, sampleRate);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::reset(float x0) {
bw_peak_reset_coeffs(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++)
bw_peak_reset_state(&coeffs, states + i, x0);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::process(
std::array<const float *, N_CHANNELS> x,
std::array<float *, N_CHANNELS> y,
int nSamples) {
bw_peak_process_multi(&coeffs, statesP, x.data(), y.data(), N_CHANNELS, nSamples);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setCutoff(float value) {
bw_peak_set_cutoff(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setQ(float value) {
bw_peak_set_Q(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setPeakGainLin(float value) {
bw_peak_set_peak_gain_lin(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setPeakGainDB(float value) {
bw_peak_set_peak_gain_dB(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setBandwidth(float value) {
bw_peak_set_bandwidth(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void Peak<N_CHANNELS>::setUseBandwidth(bool value) {
bw_peak_set_use_bandwidth(&coeffs, value);
}
}
#endif

103
include/bwpp_phase_gen.h
View File

@ -1,103 +0,0 @@
/*
* Brickworks
*
* Copyright (C) 2023 Orastron Srl unipersonale
*
* Brickworks is free software: you can rephase_genribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3 of the License.
*
* Brickworks is phase_genributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Brickworks. If not, see <http://www.gnu.org/licenses/>.
*
* File author: Stefano D'Angelo
*/
#ifndef BWPP_PHASE_GEN_H
#define BWPP_PHASE_GEN_H
#include <bw_phase_gen.h>
#include <array>
namespace Brickworks {
/*! api {{{
* ##### Brickworks::PhaseGen
* ```>>> */
template<size_t N_CHANNELS>
class PhaseGen {
public:
PhaseGen();
void setSampleRate(float sampleRate);
void reset(float phase_0 = 0.f);
void process(
std::array<const float *, N_CHANNELS> x_mod,
std::array<float *, N_CHANNELS> y,
std::array<float *, N_CHANNELS> y_phase_inc,
int nSamples);
void setFrequency(float value);
void setPortamentoTau(float value);
/*! <<<...
* }
* ```
* }}} */
/*** Implementation ***/
/* WARNING: This part of the file is not part of the public API. Its content may
* change at any time in future versions. Please, do not use it directly. */
private:
bw_phase_gen_coeffs coeffs;
bw_phase_gen_state states[N_CHANNELS];
bw_phase_gen_state *statesP[N_CHANNELS];
};
template<size_t N_CHANNELS>
inline PhaseGen<N_CHANNELS>::PhaseGen() {
bw_phase_gen_init(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++)
statesP[i] = states + i;
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::setSampleRate(float sampleRate) {
bw_phase_gen_set_sample_rate(&coeffs, sampleRate);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::reset(float phase_0) {
bw_phase_gen_reset_coeffs(&coeffs);
for (size_t i = 0; i < N_CHANNELS; i++)
bw_phase_gen_reset_state(&coeffs, states + i, phase_0);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::process(
std::array<const float *, N_CHANNELS> x_mod,
std::array<float *, N_CHANNELS> y,
std::array<float *, N_CHANNELS> y_phase_inc,
int nSamples) {
bw_phase_gen_process_multi(&coeffs, statesP, x_mod.data(), y.data(), y_phase_inc.data(), N_CHANNELS, nSamples);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::setFrequency(float value) {
bw_phase_gen_set_frequency(&coeffs, value);
}
template<size_t N_CHANNELS>
inline void PhaseGen<N_CHANNELS>::setPortamentoTau(float value) {
bw_phase_gen_set_portamento_tau(&coeffs, value);
}
}
#endif