Struct spectrusty_audio::synth::BandLimited

pub struct BandLimited<T, O = BandLimWide> { /* private fields */ }

Bandwidth-Limited Pulse Buffer implementation with high-pass and low-pass filtering, for an efficient band-limited synthesis.

T specifies pulse step amplitude unit types. Currently, implementations are provided for: f32, i16, and i32.

Implementations

impl<T: Copy + Default, O> BandLimited<T, O>

pub fn reset(&mut self)

Clears buffered data and resets frame start to default.

pub fn shrink_to_fit(&mut self)

Shrinks the excessive capacity of the buffer as much as possible.

pub fn set_frame_time(&mut self, frame_time: f64, margin_time: f64)

Ensures the frame buffer length is large enough to fit data for the specified frame_time with additional margin_time.

Sets the duration of the average frame to frame_time which should be specified with as much precision as possible.

margin_time specifies a frame duration fluctuation margin and should be significantly smaller than frame_time.

Both frame_time and margin_time are specified in the sample time units (1.0 = 1 audio sample).

Examples found in repository

src/synth.rs (line 339)

    fn ensure_frame_time(&mut self, sample_rate: u32, ts_rate: f64, frame_ts: FTs, margin_ts: FTs) {
        let time_rate = sample_rate as f64 / ts_rate;
        assert!(time_rate > 0.0);
        let frame_time = time_rate * frame_ts as f64;
        assert!(frame_time > 0.0);
        let margin_time = time_rate * 2.0 * margin_ts as f64;
        assert!(margin_time >= 0.0);
        self.time_rate = time_rate;
        self.set_frame_time(frame_time, margin_time);
    }

pub fn is_frame_ended(&mut self) -> bool

Returns true if BandLimited::end_frame has been called before the call to BandLimited::next_frame.

It indicates if audio samples can be digitized from the last frame data.

pub fn end_frame(&mut self, time_end: f64) -> usize

Finalizes audio frame.

Returns the number of audio samples, single channel-wise, which are ready to be produced from the frame.

time_end is specified in the sample time units (1.0 = 1 audio sample).

Examples found in repository

src/synth.rs (line 345)

    fn end_frame(&mut self, timestamp: FTs) -> usize {
        debug_assert!(timestamp > 0);
        self.end_frame(self.time_rate * timestamp as f64)
    }

impl<T, O> BandLimited<T, O>where
    T: Copy + Default + AddAssign + MulNorm + FromSample<f32>,
    O: BandLimOpt,

pub fn new(channels: usize) -> Self

Returns a new instance of BandLimited buffer.

• channels - specifies the maximum number of audio channels that the sound can be rendered for.

Before any pulse steps are added to the buffer the method BandLimited::set_frame_time or Blep::ensure_frame_time must be called first.

Panics

Panics if channels equals to 0.

pub fn next_frame(&mut self)

Prepares the buffer for the next audio frame.

This method must be called after the call to BandLimited::end_frame or to Blep::end_frame and optionally after audio data has been produced with BandLimited::sum_iter.

impl<T, O> BandLimited<T, O>where
    T: Copy + MulNorm + FromSample<f32>,
    O: BandLimOpt,

pub fn sum_iter<'a, S: 'a>(
    &'a self,
    channel: usize
) -> impl Iterator<Item = S> + ExactSizeIterator + 'awhere
    T: IntoSample<S>,

Returns an iterator that produces audio samples in the specified sample format S from the specified channel.

This method must be called after the call to BandLimited::end_frame or Blep::end_frame and before BandLimited::next_frame.

Trait Implementations

impl<T, O> Blep for BandLimited<T, O>where
    T: Copy + Default + SampleDelta + MulNorm,

type SampleDelta = T

A type for sample ∆ amplitudes (pulse height).

fn ensure_frame_time(
    &mut self,
    sample_rate: u32,
    ts_rate: f64,
    frame_ts: FTs,
    margin_ts: FTs
)

This method allows the Blep implementation to reserve enough memory for the audio frame with an additional margin and to set up a sample time rate and other internals.

fn end_frame(&mut self, timestamp: FTs) -> usize

Finalizes audio frame.

fn add_step(&mut self, channel: usize, timestamp: FTs, delta: T)

This method is being used to add square-wave pulse steps within a boundary of a single frame.