Voices independent LadderFilterT voices advanced together. More...

#include <ladder_bank.hpp>

Public Types
using	Filter = LadderFilterT<SampleType>

Public Member Functions
	LadderBankT ()
void	set_sample_rate (SampleType sample_rate)
	Set the sample rate every voice runs at, and recompute every voice's coefficient for its current frequency.
SampleType	sample_rate () const
void	set_frequency (std::size_t voice, SampleType hz)
void	set_resonance (std::size_t voice, SampleType resonance)
SampleType	frequency (std::size_t voice) const
SampleType	resonance (std::size_t voice) const
SampleType	stage_coefficient (std::size_t voice) const
	The voice's per-stage one-pole coefficient (Filter::stage_coefficient()).
void	process (const SampleType in, SampleType out)
	Advance every voice by one sample: out[v] = voice v's output for in[v].
void	process_voices (SampleType const buffers, std::size_t num_samples)
	Advance every voice by num_samples samples in place, one buffer per voice (buffers[v] holds voice v's input and receives its output).
void	reset (std::size_t voice)
	Clear one voice's state.
void	reset ()
	Clear every voice's state.

Static Public Attributes
static constexpr std::size_t	voice_count = Voices

Detailed Description

template<typename SampleType = float, std::size_t Voices = 16>
class pulp::signal::LadderBankT< SampleType, Voices >

Voices independent LadderFilterT voices advanced together.

Contract:

Each voice's output is bit-identical to a LadderFilterT<SampleType> with the same sample rate, frequency and resonance, driven with the same inputs through LadderFilterT::process() (the default saturator, LadderSaturation / kDefaultLadderSaturation), from the same reset state. One sample rate applies to every voice; set_sample_rate() recomputes every voice's coefficient at once (LadderFilterT applies a new rate only at its next set_frequency() or set_resonance(), so match it by setting the rate before the frequencies). The other setters have LadderFilterT's semantics.
Voices share nothing but storage: changing or resetting one voice never affects another.
process() advances every voice by one sample; process_voices() advances every voice by a block, one buffer per voice.
The per-stage coefficient and the saturator are the ones LadderFilterT exposes (stage_coefficient(), saturate()), so a widget or test can reproduce a voice without running the bank.

Selects inside the per-voice loops are bit operations (detail:: select_bits) with the same values as the scalar filter's conditionals, so the loops vectorize under GCC's default -ftrapping-math too.

Why it is faster: a ladder sample is a chain of five dependent saturations, so one voice at a time is latency-bound. The bank computes stage 1 of every voice, then stage 2 of every voice, and so on, with the voices' state in structure-of-arrays form; each stage is then a loop over independent voices that the compiler vectorizes and that keeps many recursions in flight.

RT contract: storage is fixed-size; every member function allocates no memory.