Struct Biquad 

pub struct Biquad { /* private fields */ }

Two-channel transposed-direct-form-II biquad.

The coefficients are designed and the recursion runs in f64; samples go in and come out as f32. A low band’s poles sit within about 2 * pi * f / rate of the unit circle, which f32 cannot resolve: at 96 kHz a 10 Hz low-pass in f32 passes DC at +1.2 dB, and at 384 kHz and above its poles round onto or past the circle, so the filter goes silent or runs away. In f64 every band of every rate up to 768 kHz is stable and within 0.1 dB of its design.

Implementations

impl Biquad

pub fn new(kind: BiquadKind, frequency: f32, q: f32, gain_db: f32) -> Self

Creates a parametric filter.

Parameters are sanitized in Processor::prepare: non-finite values fall back to 1 kHz, Q 0.707 and 0 dB, then each is clamped to the ranges this module exports.

Trait Implementations

impl Clone for Biquad

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Biquad

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Processor for Biquad

fn history_samples(&self) -> u32

Additional source history for a cold seek, excluding algorithmic delay. Built-in recursive processors use a finite settling horizon; this is an approximation to uninterrupted playback, not a bit-exact state snapshot.

fn prepare(&mut self, sample_rate: u32, _max_block: usize)

Configures non-real-time state before processing begins.

fn process( &mut self, _ctx: &ProcessCtx, inputs: &[&[f32]], outputs: &mut [&mut [f32]], )

Processes planar channel slices supplied by the host.

fn reset(&mut self)

Clears signal history without changing authored parameters.

fn save_state(&self) -> StateBlob

Serializes history at an offline chunk boundary.

fn load_state(&mut self, state: &StateBlob) -> Result<(), StateError>

Restores history saved by a processor of the same type, prepared alike, whole or not at all.

fn inputs_per_output(&self) -> usize

How many input channels the processor reads for each output channel: 1 for an effect, 2 for one that also reads a second bus after the first (a sidechain, or the other side of a crossfade). A crate::ProcessorChain gives each node only its own channels, so it takes only processors that read one.

fn latency_samples(&self) -> u32

Algorithmic delay that the graph host must compensate.