Struct DelayReader 

pub(crate) struct DelayReader {
    channel_info: ChannelInfo,
    delay_frames: [f32; 128],
    delay_line: Arc<RwLock<VecDeque<Block>>>,
    upmixed_block: Arc<RwLock<Option<UpmixedBlock>>>,
    delay_time: Param,
}

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

…an object that has the same interface as an AudioNode, and that can read the audio data from the internal buffer of the DelayNode. It is connected to the same AudioNodes as the DelayNode it was created from.

Fields

channel_info: ChannelInfo

delay_frames: [f32; 128]

delay_line: Arc<RwLock<VecDeque<Block>>>

upmixed_block: Arc<RwLock<Option<UpmixedBlock>>>

delay_time: Param

Implementations

impl DelayReader

pub(super) fn new( buffer: Arc<RwLock<VecDeque<Block>>>, upmixed_block: Arc<RwLock<Option<UpmixedBlock>>>, delay_time: Param, channel_info: ChannelInfo, ) -> Self

fn update_parameters(&mut self, info: &BlockInfo, tick: Tick) -> bool

https://webaudio.github.io/web-audio-api/#dom-delaynode-delaytime

fn update_delay_frames(&mut self, tick: usize, value: f32)

1.18.4

When producing an output buffer, a DelayReader MUST yield exactly the audio that was written to the corresponding DelayWriter delayTime seconds ago.

We are processing tick t, where t ranges from 0 to (FRAMES_PER_BLOCK - 1). The DelayWriter is writing a frame into the delay line every tick. Let delay_frame = delay_time * sample_rate, at tick t. Now let’s process tick t + 1. delay_frame must increase by 1 to account for the new tick. There are FRAMES_PER_BLOCK - 1 - t ticks to process after tick t. So after processing all ticks (FRAMES_PER_BLOCK - 1), delay_frames[t] = delay_time * sample_rate + FRAMES_PER_BLOCK - 1 - t

fn calc_output_channel_count(&self) -> u8

Calculates the output channel count https://webaudio.github.io/web-audio-api/#tail-time 4.3

When an AudioNode has a non-zero tail-time, and an output channel count that depends on the input channels count, the AudioNode’s tail-time must be taken into account when the input channel count changes.

When there is a decrease in input channel count, the change in output channel count MUST happen when the input that was received with greater channel count no longer affects the output.

When there is an increase in input channel count, the behavior depends on the AudioNode type:

• For a DelayNode or a DynamicsCompressorNode, the number of output channels MUST increase when the input that was received with greater channel count begins to affect the output.

Therefore, we know that output channel count will be the highest channel count of the blocks read.

fn upmix_block( &self, index: usize, channel_count: u8, block: &Block, ) -> UpmixedBlock

pub(super) fn read(&mut self) -> Chunk

Read frames from the delay line at the values indexed around the specified delays.

Trait Implementations

impl AudioNodeCommon for DelayReader

fn channel_info(&self) -> &ChannelInfo

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

impl AudioNodeEngine for DelayReader

fn node_type(&self) -> AudioNodeType

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

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

fn mute_node(&mut self) -> Chunk

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

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

fn message_specific(&mut self, _: AudioNodeMessage, _sample_rate: f32)

Messages specific to this node

fn input_count(&self) -> u32

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)