Struct awedio::sounds::SoundsFromFn

pub struct SoundsFromFn { /* private fields */ }

Play sounds produced by a function returning sounds one after the other.

The generator function is called after each previously produced sound has returned finished. After SoundsFromFn returns None this sound returns Finished. If an Error is returned from next_sound that sound is dropped and the Error is returned. If next_sound is called again SoundsFromFn is called again.

This can be used to create sounds that loop forever without storing all samples in memory.

Implementations

impl SoundsFromFn

pub fn new(generator: Box<dyn FnMut() -> Option<Box<dyn Sound>> + Send>) -> Self

Call generator to generate Sounds that will be played to completion. If generator returns None, this Sound will be Finished and generator will no longer be called.

Examples

Play an audio file forever.

use awedio::sounds::{SoundsFromFn, open_file};

let generator = || Some(open_file("test.wav").unwrap());
let forever_sound = SoundsFromFn::new(Box::new(generator));

Trait Implementations

impl Sound for SoundsFromFn

fn channel_count(&self) -> u16

Returns the number of channels.

fn sample_rate(&self) -> u32

Returns the number of samples per second for each channel for this sound (e.g. 44,100).

fn on_start_of_batch(&mut self)

Called whenever a new batch of audio samples is requested by the backend.

fn next_sample(&mut self) -> Result<NextSample, Error>

Retrieve the next sample or notification if something has changed. The first sample is for the first channel and the second is the for second and so on until channel_count and then wraps back to the first channel. If any NextSample variant besides Sample is returned then the following NextSample::Sample is for the first channel. If a Sound has returned Paused it is expected that the consumer will call next_sample again in the future. If a Sound has returned Finished it is not expected for the consumer to call next_sample again but if called Finished will normally be returned again. After Finished has been returned, channel_count() and sample_rate() may return different values without MetadataChanged being returned.

fn next_frame(&mut self) -> Result<Vec<i16>, Result<NextSample, Error>>

Returns the next sample for all channels.

fn append_next_frame_to( &mut self, samples: &mut Vec<i16> ) -> Result<(), Result<NextSample, Error>>

Same as next_frame but samples are appended into an existing Vec.

fn into_memory_sound(self) -> Result<MemorySound, Error>

where Self: Sized,

Read the entire sound into memory. MemorySound can be cloned for efficient reuse. See MemorySound::from_sound.

fn loop_from_memory(self) -> Result<MemorySound, Error>

where Self: Sized,

Read the entire sound into memory and loop indefinitely.

fn controllable(self) -> (Controllable<Self>, Controller<Self>)

where Self: Sized,

Allow this sound to be controlled after it has started playing with a Controller.

fn with_async_completion_notifier( self ) -> (AsyncCompletionNotifier<Self>, Receiver<()>)

where Self: Sized,

Get notified via a tokio::sync::oneshot::Receiver when this sound has Finished.

fn with_completion_notifier(self) -> (CompletionNotifier<Self>, Receiver<()>)

where Self: Sized,

Get notified via a std::sync::mpsc::Receiver when this sound has Finished.

fn with_adjustable_volume(self) -> AdjustableVolume<Self>

where Self: Sized,

Allow the volume of the sound to be adjustable with set_volume.

fn with_adjustable_volume_of( self, volume_adjustment: f32 ) -> AdjustableVolume<Self>

where Self: Sized,

Allow the volume of the sound to be adjustable with set_volume and set the initial volume adjustment.

fn with_adjustable_speed(self) -> AdjustableSpeed<Self>

where Self: Sized,

Allow the speed of the sound to be adjustable with set_speed.

fn with_adjustable_speed_of( self, speed_adjustment: f32 ) -> AdjustableSpeed<Self>

where Self: Sized,

Allow the speed of the sound to be adjustable with set_speed and set the initial speed adjustment.

fn pausable(self) -> Pausable<Self>

where Self: Sized,

Allow for the sound to be pausable with set_paused. Starts unpaused.

fn paused(self) -> Pausable<Self>

where Self: Sized,

Allow for the sound to be pausable with set_paused. Starts paused.

fn finish_after(self, duration: Duration) -> FinishAfter<Self>

where Self: Sized,

Play the first duration of the sound, then finish even if samples remain.