Struct TimeStretchProcessor 

pub struct TimeStretchProcessor { /* private fields */ }

Deterministic two-tap delay-line pitch shifter with a fixed prepared window (20 ms).

It does not change duration: a host that plays a source rate times as fast (which also transposes it by rate) runs it through this processor to transpose it by pitch / rate, so the result plays at rate with its pitch scaled by pitch. Two taps read the input’s recent history at delays that sweep one window at the transposition’s speed, half a window apart; each fades to nothing where its sweep wraps, so neither jumps while it is heard, and their weights sum to one. Untransposed (pitch == rate), the output is the input delayed by exactly Processor::latency_samples, one window, which is also the mean delay of a transposed output and does not depend on the ratios. Hosts provide continuous project-rate blocks and may save/restore the complete history.

Implementations

impl TimeStretchProcessor

pub fn new(rate: f32, pitch: f32) -> Self

Creates a processor. Both ratios are clamped to 0.25 to 4.0; a non-finite ratio becomes 1.0.

pub fn set_ratios(&mut self, rate: f32, pitch: f32)

Updates time and pitch ratios without resetting history. The latency does not change.

pub fn set_bypass(&mut self, bypass: bool)

Enables latency-preserving bypass: the input delayed by Processor::latency_samples, while the history keeps following it.

Trait Implementations

impl Clone for TimeStretchProcessor

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 TimeStretchProcessor

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

Formats the value using the given formatter.

impl Processor for TimeStretchProcessor

fn latency_samples(&self) -> u32

One window: an untransposed output’s delay, and a transposed one’s mean, whatever the ratios.

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 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.