Struct web_audio_api::node::AudioBufferSourceNode

pub struct AudioBufferSourceNode { /* fields omitted */ }

AudioBufferSourceNode represents an audio source that consists of an in-memory audio source (i.e. an audio file completely loaded in memory), stored in an AudioBuffer.

• MDN documentation: https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode
• specification: https://webaudio.github.io/web-audio-api/#AudioBufferSourceNode
• see also: AsBaseAudioContext::create_buffer_source

Usage

use std::fs::File;
use web_audio_api::context::{AsBaseAudioContext, AudioContext};
use web_audio_api::node::AudioNode;

// create an `AudioContext`
let context = AudioContext::new(None);
// load and decode a soundfile
let file = File::open("sample.wav").unwrap();
let audio_buffer = context.decode_audio_data(file);
// play the sound file
let mut src = context.create_buffer_source();
src.set_buffer(&audio_buffer);
src.connect(&context.destination());
src.start();

Examples

• cargo run --release --example trigger_soundfile
• cargo run --release --example granular

Implementations

impl AudioBufferSourceNode

pub fn new<C: AsBaseAudioContext>(
    context: &C,
    options: AudioBufferSourceOptions
) -> Self

Create a new AudioBufferSourceNode instance

pub fn set_buffer(&mut self, audio_buffer: &AudioBuffer)

Provide an AudioBuffer as the source of data to be played bask

Panics

Panics if a buffer has already been given to the source (though new or through set_buffer)

pub fn start(&mut self)

Start the playback on next block

pub fn start_at(&mut self, start: f64)

Start the playback at the given time

pub fn start_at_with_offset(&mut self, start: f64, offset: f64)

Start the playback at the given time and with a given offset

pub fn start_at_with_offset_and_duration(
    &mut self,
    start: f64,
    offset: f64,
    duration: f64
)

Start the playback at the given time, with a given offset, for a given duration

pub fn stop(&mut self)

Stop the playback on next block

pub fn stop_at(&mut self, stop: f64)

Stop the playback at given time

pub fn playback_rate(&self) -> &AudioParam

AudioParam that defines the speed at which the AudioBuffer will be played, e.g.:

• 0.5 will play the file at half speed
• -1 will play the file in reverse

Note that playback rate will also alter the pitch of the AudioBuffer

pub fn detune(&self) -> &AudioParam

AudioParam that defines a pitch transposition of the file, expressed in cents

see https://en.wikipedia.org/wiki/Cent_(music)

pub fn loop_(&self) -> bool

Defines if the playback the AudioBuffer should be looped

pub fn set_loop(&self, value: bool)

pub fn loop_start(&self) -> f64

Defines the loop start point, in the time reference of the AudioBuffer

pub fn set_loop_start(&self, value: f64)

pub fn loop_end(&self) -> f64

Defines the loop end point, in the time reference of the AudioBuffer

pub fn set_loop_end(&self, value: f64)

Trait Implementations

impl AudioNode for AudioBufferSourceNode

fn registration(&self) -> &AudioContextRegistration

fn channel_config_raw(&self) -> &ChannelConfig

fn number_of_inputs(&self) -> u32

The number of inputs feeding into the AudioNode. For source nodes, this will be 0.

fn number_of_outputs(&self) -> u32

The number of outputs coming out of the AudioNode.

fn id(&self) -> &AudioNodeId

fn channel_config_cloned(&self) -> ChannelConfig

fn context(&self) -> &BaseAudioContext

The BaseAudioContext which owns this AudioNode.

fn connect<'a>(&self, dest: &'a dyn AudioNode) -> &'a dyn AudioNode

Connect the output of this AudioNode to the input of another node.

fn connect_at<'a>(
    &self,
    dest: &'a dyn AudioNode,
    output: u32,
    input: u32
) -> Result<&'a dyn AudioNode, IndexSizeError>

Connect a specific output of this AudioNode to a specific input of another node.

fn disconnect<'a>(&self, dest: &'a dyn AudioNode) -> &'a dyn AudioNode

Disconnects all outputs of the AudioNode that go to a specific destination AudioNode.

fn disconnect_all(&self)

Disconnects all outgoing connections from the AudioNode.

fn channel_count_mode(&self) -> ChannelCountMode

Represents an enumerated value describing the way channels must be matched between the node’s inputs and outputs.

fn set_channel_count_mode(&self, v: ChannelCountMode)

fn channel_interpretation(&self) -> ChannelInterpretation

Represents an enumerated value describing the meaning of the channels. This interpretation will define how audio up-mixing and down-mixing will happen.

fn set_channel_interpretation(&self, v: ChannelInterpretation)

fn channel_count(&self) -> usize

Represents an integer used to determine how many channels are used when up-mixing and down-mixing connections to any inputs to the node.

fn set_channel_count(&self, v: usize)