Struct dasp::signal::interpolate::Converter

pub struct Converter<S, I> where
    I: Interpolator,
    S: Signal,  { /* fields omitted */ }

A signal type that converts the rate at which frames are yielded from some source signal to some target rate.

Other names for sample::interpolate::Converter might include:

• Sample rate converter.
• {Up/Down}sampler.
• Sample interpolater.
• Sample decimator.

Implementations

impl<S, I> Converter<S, I> where
    I: Interpolator,
    S: Signal, 

pub fn from_hz_to_hz(
    source: S,
    interpolator: I,
    source_hz: f64,
    target_hz: f64
) -> Converter<S, I>

Construct a new Converter from the source frames and the source and target sample rates (in Hz).

pub fn scale_playback_hz(
    source: S,
    interpolator: I,
    scale: f64
) -> Converter<S, I>

Construct a new Converter from the source frames and the amount by which the current playback rate (not sample rate) should be multiplied to reach the new playback rate.

For example, if our source_frames is a sine wave oscillating at a frequency of 2hz and we wanted to convert it to a frequency of 3hz, the given scale should be 1.5.

pub fn scale_sample_hz(
    source: S,
    interpolator: I,
    scale: f64
) -> Converter<S, I>

Construct a new Converter from the source frames and the amount by which the current sample rate (not playback rate) should be multiplied to reach the new sample rate.

If our source_frames are being sampled at a rate of 44_100hz and we want to convert to a sample rate of 96_000hz, the given scale should be 96_000.0 / 44_100.0.

This is the same as calling Converter::scale_playback_hz(source_frames, 1.0 / scale).

pub fn set_hz_to_hz(&mut self, source_hz: f64, target_hz: f64)

Update the source_to_target_ratio internally given the source and target hz.

This method might be useful for changing the sample rate during playback.

pub fn set_playback_hz_scale(&mut self, scale: f64)

Update the source_to_target_ratio internally given a new playback rate multiplier.

This method is useful for dynamically changing rates.

pub fn set_sample_hz_scale(&mut self, scale: f64)

Update the source_to_target_ratio internally given a new sample rate multiplier.

This method is useful for dynamically changing rates.

pub fn source(&self) -> &S

Borrow the source_frames Interpolator from the Converter.

pub fn source_mut(&mut self) -> &mut S

Mutably borrow the source_frames Iterator from the Converter.

pub fn into_source(self) -> S

Drop self and return the internal source_frames Iterator.

Trait Implementations

impl<S, I> Clone for Converter<S, I> where
    I: Clone + Interpolator,
    S: Clone + Signal, 

fn clone(&self) -> Converter<S, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, I> Signal for Converter<S, I> where
    I: Interpolator<Frame = <S as Signal>::Frame>,
    S: Signal, 

type Frame = <S as Signal>::Frame

The Frame type returned by the Signal.

fn next(&mut self) -> <Converter<S, I> as Signal>::Frame

Yield the next Frame in the Signal.

fn is_exhausted(&self) -> bool

Whether or not the signal is exhausted of meaningful frames.

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

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
    F: Frame,
    M: FnMut(Self::Frame, <O as Signal>::Frame) -> F,
    O: Signal, 

A signal that maps one set of frames to another.

fn add_amp<S>(self, other: S) -> AddAmp<Self, S> where
    S: Signal,
    <S as Signal>::Frame: Frame,
    <<S as Signal>::Frame as Frame>::Sample == <<Self::Frame as Frame>::Sample as Sample>::Signed,
    <<S as Signal>::Frame as Frame>::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
    S: Signal,
    <S as Signal>::Frame: Frame,
    <<S as Signal>::Frame as Frame>::Sample == <<Self::Frame as Frame>::Sample as Sample>::Float,
    <<S as Signal>::Frame as Frame>::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>

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>

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
    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
    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
    I: Interpolator,
    M: Signal<Frame = f64>, 

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

Delays the Signal by the given number of frames.

fn into_interleaved_samples(self) -> IntoInterleavedSamples<Self>

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>

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
    F: FnMut(&Self::Frame), 

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

fn fork<S>(self, ring_buffer: Bounded<S>) -> Fork<Self, S> where
    S: SliceMut<Element = Self::Frame>, 

Forks Self into two signals that produce the same frames.

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

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

fn until_exhausted(self) -> UntilExhausted<Self>

Converts the Signal into an Iterator yielding frames until the signal.is_exhausted() returns true.

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

Buffers the signal using the given ring buffer.

fn by_ref(&mut self) -> &mut Self

Borrows a Signal rather than consuming it.