Struct servo_media_audio::buffer_source_node::AudioBufferSourceNode

pub(crate) struct AudioBufferSourceNode {

    channel_info: ChannelInfo,
    buffer: Option<AudioBuffer>,
    buffer_duration: f64,
    buffer_pos: f64,
    detune: Param,
    initialized_pos: bool,
    loop_enabled: bool,
    loop_end: Option<f64>,
    loop_start: Option<f64>,
    playback_rate: Param,
    start_at: Option<Tick>,
    start_offset: Option<f64>,
    start_duration: Option<f64>,
    start_when: f64,
    stop_at: Option<Tick>,
    pub onended_callback: Option<OnEndedCallback>,
}

AudioBufferSourceNode engine. https://webaudio.github.io/web-audio-api/#AudioBufferSourceNode

Fields

channel_info: ChannelInfo

buffer: Option<AudioBuffer>

A data block holding the audio sample data to be played.

buffer_duration: f64

How many more buffer-frames to output. See buffer_pos for clarification.

buffer_pos: f64

“Index” of the next buffer frame to play. “Index” is in quotes because this variable maps to a playhead position (the offset in seconds can be obtained by dividing by self.buffer.sample_rate), and therefore has subsample accuracy; a fractional “index” means interpolation is needed.

detune: Param

AudioParam to modulate the speed at which is rendered the audio stream.

initialized_pos: bool

Whether we need to compute offsets from scratch.

loop_enabled: bool

Indicates if the region of audio data designated by loopStart and loopEnd should be played continuously in a loop.

loop_end: Option<f64>

An playhead position where looping should end if the loop_enabled attribute is true.

loop_start: Option<f64>

An playhead position where looping should begin if the loop_enabled attribute is true.

playback_rate: Param

The speed at which to render the audio stream. Can be negative if the audio is to be played backwards. With a negative playback_rate, looping jumps from loop_start to loop_end instead of the other way around.

start_at: Option<Tick>

Time at which the source should start playing.

start_offset: Option<f64>

Offset parameter passed to Start().

start_duration: Option<f64>

Duration parameter passed to Start().

start_when: f64

The same as start_at, but with subsample accuracy. FIXME: AudioScheduledSourceNode should use this as well.

stop_at: Option<Tick>

Time at which the source should stop playing.

onended_callback: Option<OnEndedCallback>

The ended event callback.

Implementations

impl AudioBufferSourceNode

fn should_play_at(&mut self, tick: Tick) -> ShouldPlay

fn start(&mut self, tick: Tick) -> bool

fn stop(&mut self, tick: Tick) -> bool

fn maybe_trigger_onended_callback(&mut self)

fn handle_source_node_message( &mut self, message: AudioScheduledSourceNodeMessage, sample_rate: f32, )

impl AudioBufferSourceNode

pub fn new( options: AudioBufferSourceNodeOptions, channel_info: ChannelInfo, ) -> Self

pub fn handle_message(&mut self, message: AudioBufferSourceNodeMessage, _: f32)

Trait Implementations

impl AudioNodeCommon for AudioBufferSourceNode

fn channel_info(&self) -> &ChannelInfo

fn channel_info_mut(&mut self) -> &mut ChannelInfo

impl AudioNodeEngine for AudioBufferSourceNode

fn node_type(&self) -> AudioNodeType

fn input_count(&self) -> u32

fn process(&mut self, inputs: Chunk, info: &BlockInfo) -> Chunk

fn get_param(&mut self, id: ParamType) -> &mut Param

fn message_specific(&mut self, msg: AudioNodeMessage, sample_rate: f32)

Messages specific to this node

fn message(&mut self, msg: AudioNodeMessage, sample_rate: f32)

fn output_count(&self) -> u32

fn channel_count(&self) -> u8

Number of input channels for each input port

fn channel_count_mode(&self) -> ChannelCountMode

fn channel_interpretation(&self) -> ChannelInterpretation

fn set_channel_interpretation(&mut self, i: ChannelInterpretation)

fn set_channel_count(&mut self, c: u8)

fn set_channel_count_mode(&mut self, m: ChannelCountMode)

fn destination_data(&mut self) -> Option<Chunk>

If we’re the destination node, extract the contained data

fn set_listenerdata(&mut self, _: Block)