Struct web_audio_api::node::MediaStreamAudioDestinationNode

pub struct MediaStreamAudioDestinationNode { /* private fields */ }

An audio stream destination (e.g. WebRTC sink)

• MDN documentation: https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioDestinationNode
• specification: https://www.w3.org/TR/webaudio/#mediastreamaudiodestinationnode
• see also: AudioContext::create_media_stream_destination

Since the w3c MediaStream interface is not part of this library, we cannot adhere to the official specification. Instead, you can pass in any callback that handles audio buffers.

IMPORTANT: you must consume the buffers faster than the render thread produces them, or you will miss frames. Consider to spin up a dedicated thread to consume the buffers and cache them.

Usage

use web_audio_api::context::{AudioContext, BaseAudioContext};
use web_audio_api::node::{AudioNode, AudioScheduledSourceNode};

// Create an audio context where all audio nodes lives
let context = AudioContext::default();

// Create an oscillator node with sine (default) type
let osc = context.create_oscillator();

// Create a media destination node
let dest = context.create_media_stream_destination();
osc.connect(&dest);
osc.start();

// Handle recorded buffers
println!("samples recorded:");
let mut samples_recorded = 0;
for item in dest.stream() {
    let buffer = item.unwrap();

    // You could write the samples to a file here.
    samples_recorded += buffer.length();
    print!("{}\r", samples_recorded);
}

Examples

• cargo run --release --example recorder

Implementations

impl MediaStreamAudioDestinationNode

pub fn new<C: BaseAudioContext>(
    context: &C,
    options: ChannelConfigOptions
) -> Self

Create a new MediaStreamAudioDestinationNode

pub fn stream(&self) -> impl MediaStream

A MediaStream iterator producing audio buffers with the same number of channels as the node itself

Note that while you can call this function multiple times and poll all iterators concurrently, this could lead to unexpected behavior as the buffers will only be offered once.

Trait Implementations

impl AudioNode for MediaStreamAudioDestinationNode

fn registration(&self) -> &AudioContextRegistration

fn channel_config(&self) -> &ChannelConfig

fn number_of_inputs(&self) -> usize

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

fn number_of_outputs(&self) -> usize

The number of outputs coming out of the AudioNode.

fn context(&self) -> &ConcreteBaseAudioContext

The BaseAudioContext concrete type 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: usize,
    input: usize
) -> &'a dyn AudioNode

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

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

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

fn disconnect(&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)

Update the channel_count_mode attribute

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)

Update the channel_interpretation attribute

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)

Update the channel_count attribute