Struct Mixer 

pub struct Mixer { /* private fields */ }

The mix (module docs).

Implementations

impl Mixer

pub fn new(config: Config) -> Self

A mixer for config, with all the memory it will ever use.

pub const fn config(&self) -> Config

Its output’s format.

pub fn remote(&self, commands: usize) -> (Remote, Inbox)

The two ends for commanding this mixer from another thread, with room for commands commands waiting (queue).

pub fn put_sound(&mut self, sound: SoundId, pcm: SharedPcm) -> Option<SharedPcm>

Puts pcm in the place of the bank Remote::reserve_sound named, and gives back what was there for the caller to free. It neither allocates nor frees, so a backend’s hand-over can call it on the audio thread.

pub fn put_stream( &mut self, stream: StreamId, source: Box<dyn Source + Send>, ) -> Option<Box<dyn Source + Send>>

Holds source in the stream slot Remote::reserve_stream named, and gives back what was there for the caller to free. It neither allocates nor frees.

pub fn take_stream( &mut self, stream: StreamId, ) -> Option<Box<dyn Source + Send>>

Takes stream out of its slot, ending what is playing it, for the caller to free where it may. A mix never frees one.

pub fn add_sound(&mut self, pcm: SharedPcm) -> Result<SoundId, Full>

Puts pcm in the bank.

pub fn remove_sound(&mut self, sound: SoundId) -> Option<SharedPcm>

Takes sound out of the bank and stops what is playing it. The caller frees it, on a thread that may.

pub fn add_stream( &mut self, source: Box<dyn Source + Send>, ) -> Result<StreamId, Full>

Holds source ready to play. A slot that a finished stream still holds is freed for it; a backend with its mixer on the audio thread takes those out first (take_finished_stream).

pub fn take_finished_stream(&mut self) -> Option<Box<dyn Source + Send>>

A source whose voice has finished with it, for the caller to free where it may. A mix never frees one.

pub fn play(&mut self, sound: SoundId, params: Params) -> Result<VoiceId, Full>

Plays sound, or says Full. A sound no longer in the bank plays as one with no frames.

pub fn stream( &mut self, source: impl Source + Send + 'static, params: Params, ) -> Result<VoiceId, Full>

Plays source, a stream that has its frames ready, or says Full.

pub fn play_stream( &mut self, stream: StreamId, params: Params, ) -> Result<VoiceId, Full>

Plays a stream add_stream holds, or says Full. A stream plays once: one that was played, or is gone, plays as one with no frames.

pub fn set_volume(&mut self, voice: VoiceId, volume: u16)

Jumps to volume, in 1/4096, ending any fade.

pub fn fade_to(&mut self, voice: VoiceId, volume: u16, millis: u64)

Goes to volume, in 1/4096, in a straight line, over millis. A fade to nothing leaves the voice playing silently, for the caller to stop.

pub fn set_balance(&mut self, voice: VoiceId, left: u16, right: u16)

Sets the left and right gains, in 1/4096.

pub fn stop(&mut self, voice: VoiceId)

Ends voice now.

pub fn pause(&mut self, voice: VoiceId)

Holds voice where it is, its fade too: it sounds nothing until resume.

pub fn resume(&mut self, voice: VoiceId)

Goes on from where pause held it.

pub fn is_playing(&self, voice: VoiceId) -> bool

Whether voice hasn’t ended. A paused voice is playing.

pub fn is_paused(&self, voice: VoiceId) -> bool

Whether voice is held by pause.

pub fn volume(&self, voice: VoiceId) -> Option<u16>

voice’s volume now, in 1/4096, if it is playing.

pub fn playing(&self) -> usize

How many voices are playing.

pub const fn underrun_frames(&self) -> u64

How many frames, added over every stream so far, had nothing to play yet because a worker hadn’t got there. A voice stops where it is for those: a stream is delayed, never skipped.

pub fn render(&mut self, out: &mut [i16])

Mixes every voice into out, whole frames of interleaved samples (a part of a frame at its end is silence), then removes those that finished. No lock, no allocation, nothing freed.

Trait Implementations

impl Debug for Mixer

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

Formats the value using the given formatter.