Struct hodaun::source::Map

pub struct Map<S, F> { /* private fields */ }

Source returned from Source::map

Trait Implementations

impl<S: Clone, F: Clone> Clone for Map<S, F>

fn clone(&self) -> Map<S, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, F: Debug> Debug for Map<S, F>

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

Formats the value using the given formatter.

impl<S, F, B> Source for Map<S, F>where S: Source, F: Fn(S::Frame) -> B, B: Frame,

type Frame = B

The Frame type

fn next(&mut self, sample_rate: f64) -> Option<Self::Frame>

Get the next frame

fn amplify<A>(self, amp: A) -> Amplify<Self, A>where Self: Sized, A: Automation,

Amplify the source by some multiplier

fn take(self, dur: impl ToDuration) -> Take<Self, f64>where Self: Sized,

End the source after some duration

fn take_release<R>(self, dur: impl ToDuration, release: R) -> Take<Self, R>where Self: Sized, R: Automation,

End the source after some duration and apply a release envelope

fn chain<B>(self, next: B) -> Chain<Self, B>where Self: Sized, B: Source<Frame = Self::Frame>,

Chain the source with another

fn low_pass<F>(self, freq: F) -> LowPass<Self, F>where Self: Sized, F: Automation,

Apply a low-pass filter with the given cut-off frequency

fn map<F, B>(self, f: F) -> Map<Self, F>where Self: Sized, F: Fn(Self::Frame) -> B,

Transform each frame with the given function

fn zip<F, B>(self, other: B, f: F) -> Zip<Self, B, F>where Self: Sized, B: Source, F: Fn(Self::Frame, B::Frame) -> Self::Frame,

Combine this source with another using the given frame-combining function

fn mix<B>( self, other: B ) -> Zip<Self, B, fn(_: Self::Frame, _: Self::Frame) -> Self::Frame>where Self: Sized, B: Source<Frame = Self::Frame>,

Combine this source with another by adding their frames

fn pan<P>(self, pan: P) -> Pan<Self, P>where Self: Sized, P: Automation,

Apply a pan to the source

fn positive(self) -> Positive<Self>where Self: Sized,

Map the source’s amplitude’s range from [-1, 1] to [0, 1]

fn repeat(self, n: usize) -> Repeat<Self, f64>where Self: Sized,

Repeat a source n times

fn repeat_indefinitely(self) -> Repeat<Self, f64>where Self: Sized,

Repeat a source indefinitely

fn no_repeat(self) -> NoRepeat<Self>where Self: Sized,

When repeated, make the source continue where it left off instead of starting over

fn ads<A, D, S>(self, envelope: AdsEnvelope<A, D, S>) -> Ads<Self, A, D, S>where Self: Sized, A: Automation, D: Automation, S: Automation,

Apply an attack-decay-sustain envelope to the source

fn maintained<R>(self, maintainer: &Maintainer<R>) -> Maintained<Self, R>where Self: Sized, R: Automation + Clone,

Keep playing this source as long as the given Maintainer is not dropped

fn inspect(self) -> (SourceInspector<Self::Frame>, InspectedSource<Self>)where Self: Sized,

Allow the current frame of the source to be inspected

fn buffer(self) -> Buffered<Self>where Self: Sized,

Buffer the source

fn unroll(self, sample_rate: f64) -> Unroll<Self> where Self: Sized,

Unroll the source so that its samples are flat

impl<S: Copy, F: Copy> Copy for Map<S, F>