Struct sample::signal::Buffered

pub struct Buffered<S, D> { /* fields omitted */ }

Buffers the signal using the given ring buffer.

When next is called, Buffered will first check if the ring buffer is empty. If so, it will completely fill the ring buffer with signal before yielding the next frame.

If next is called and the ring buffer still contains un-yielded values, the next frame will be popped from the front of the ring buffer and immediately returned.

Methods

impl<S, D> Buffered<S, D> where
    S: Signal,
    D: Slice<Element = S::Frame> + SliceMut, 

fn next_frames(&mut self) -> BufferedFrames<D>

Produces an iterator yielding the next batch of buffered frames.

The returned iterator returns None once the inner ring buffer becomes exhausted.

If the inner ring buffer is empty when this method is called, the ring buffer will first be filled using Buffered's inner signal before BufferedFrames is returned.

extern crate sample;

use sample::signal::{self, Signal};
use sample::ring_buffer;

fn main() {
    let frames = [[0.1], [0.2], [0.3], [0.4]];
    let signal = signal::from_iter(frames.iter().cloned());
    let ring_buffer = ring_buffer::Bounded::<[[f32; 1]; 2]>::array();
    let mut buffered_signal = signal.buffered(ring_buffer);
    assert_eq!(buffered_signal.next_frames().collect::<Vec<_>>(), vec![[0.1], [0.2]]);
    assert_eq!(buffered_signal.next_frames().collect::<Vec<_>>(), vec![[0.3], [0.4]]);
    assert_eq!(buffered_signal.next_frames().collect::<Vec<_>>(), vec![[0.0], [0.0]]);
}

fn into_parts(self) -> (S, Bounded<D>)

Consumes the Buffered signal and returns its inner signal S and bounded ring buffer.

Trait Implementations

impl<S: Clone, D: Clone> Clone for Buffered<S, D>

fn clone(&self) -> Buffered<S, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, D> Signal for Buffered<S, D> where
    S: Signal,
    D: Slice<Element = S::Frame> + SliceMut, 

type Frame = S::Frame

The Frame type returned by the Signal.

fn next(&mut self) -> Self::Frame

Yield the next Frame in the Signal.

fn map<M, F>(self, map: M) -> Map<Self, M, F> where
    Self: Sized,
    M: FnMut(Self::Frame) -> F,
    F: Frame, 

A signal that maps one set of frames to another.

fn zip_map<O, M, F>(self, other: O, map: M) -> ZipMap<Self, O, M, F> where
    Self: Sized,
    M: FnMut(Self::Frame, O::Frame) -> F,
    O: Signal,
    F: Frame, 

A signal that maps one set of frames to another

fn add_amp<S>(self, other: S) -> AddAmp<Self, S> where
    Self: Sized,
    S: Signal,
    S::Frame: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Signed, NumChannels = <Self::Frame as Frame>::NumChannels>, 

Provides an iterator that yields the sum of the frames yielded by both other and self in lock-step.

fn mul_amp<S>(self, other: S) -> MulAmp<Self, S> where
    Self: Sized,
    S: Signal,
    S::Frame: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Float, NumChannels = <Self::Frame as Frame>::NumChannels>, 

Provides an iterator that yields the product of the frames yielded by both other and self in lock-step.

fn offset_amp(
    self,
    offset: <<Self::Frame as Frame>::Sample as Sample>::Signed
) -> OffsetAmp<Self> where
    Self: Sized, 

Provides an iterator that offsets the amplitude of every channel in each frame of the signal by some sample value and yields the resulting frames.

fn scale_amp(
    self,
    amp: <<Self::Frame as Frame>::Sample as Sample>::Float
) -> ScaleAmp<Self> where
    Self: Sized, 

Produces an Iterator that scales the amplitude of the sample of each channel in every Frame yielded by self by the given amplitude.

fn offset_amp_per_channel<F>(self, amp_frame: F) -> OffsetAmpPerChannel<Self, F> where
    Self: Sized,
    F: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Signed, NumChannels = <Self::Frame as Frame>::NumChannels>, 

Produces a new Signal that offsets the amplitude of every Frame in self by the respective amplitudes in each channel of the given amp_frame.

fn scale_amp_per_channel<F>(self, amp_frame: F) -> ScaleAmpPerChannel<Self, F> where
    Self: Sized,
    F: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Float, NumChannels = <Self::Frame as Frame>::NumChannels>, 

Produces a new Signal that scales the amplitude of every Frame in self by the respective amplitudes in each channel of the given amp_frame.

fn mul_hz<M, I>(self, interpolator: I, mul_per_frame: M) -> MulHz<Self, M, I> where
    Self: Sized,
    M: Signal<Frame = [f64; 1]>,
    I: Interpolator, 

Multiplies the rate at which frames of self are yielded by the given signal.

fn from_hz_to_hz<I>(
    self,
    interpolator: I,
    source_hz: f64,
    target_hz: f64
) -> Converter<Self, I> where
    Self: Sized,
    I: Interpolator, 

Converts the rate at which frames of the Signal are yielded using interpolation.

fn scale_hz<I>(self, interpolator: I, multi: f64) -> Converter<Self, I> where
    Self: Sized,
    I: Interpolator, 

Multiplies the rate at which frames of the Signal are yielded by the given value.

fn delay(self, n_frames: usize) -> Delay<Self> where
    Self: Sized, 

Delays the Signal by the given number of frames.

fn into_interleaved_samples(self) -> IntoInterleavedSamples<Self> where
    Self: Sized, 

Converts a Signal into a type that yields the interleaved Samples.

fn clip_amp(
    self,
    thresh: <<Self::Frame as Frame>::Sample as Sample>::Signed
) -> ClipAmp<Self> where
    Self: Sized, 

Clips the amplitude of each channel in each Frame yielded by self to the given threshold amplitude.

fn inspect<F>(self, inspect: F) -> Inspect<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Frame), 

Create a new Signal that calls the enclosing function on each iteration.

fn bus(self) -> Bus<Self> where
    Self: Sized, 

Moves the Signal into a Bus from which its output may be divided into multiple other Signals in the form of Outputs.

fn take(self, n: usize) -> Take<Self> where
    Self: Sized, 

Converts the Signal into an Iterator that will yield the given number for Frames before returning None.

fn buffered<S>(self, ring_buffer: Bounded<S>) -> Buffered<Self, S> where
    Self: Sized,
    S: Slice<Element = Self::Frame> + SliceMut, 

Buffers the signal using the given ring buffer.

fn rms<S>(self, ring_buffer: Fixed<S>) -> Rms<Self, S> where
    Self: Sized,
    S: Slice<Element = <Self::Frame as Frame>::Float> + SliceMut, 

An adaptor that yields the RMS of the signal.

fn detect_envelope<D>(
    self,
    detector: Detector<Self::Frame, D>
) -> DetectEnvelope<Self, D> where
    Self: Sized,
    D: Detect<Self::Frame>, 

An adaptor that detects and yields the envelope of the signal.

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

Borrows a Signal rather than consuming it.