Struct 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 mut 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().get_tracks()[0].iter() {
    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: AudioNodeOptions) -> Self

Create a new MediaStreamAudioDestinationNode

pub fn stream(&self) -> &MediaStream

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

Trait Implementations

impl AudioNode for MediaStreamAudioDestinationNode

fn registration(&self) -> &AudioContextRegistration

Handle of the associated BaseAudioContext.

fn channel_config(&self) -> &ChannelConfig

Config for up/down-mixing of input channels for this node.

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_from_output_to_input<'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(&self)

Disconnects all outgoing connections from the AudioNode.

fn disconnect_dest(&self, dest: &dyn AudioNode)

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

fn disconnect_output(&self, output: usize)

Disconnects all outgoing connections at the given output port from the AudioNode.

fn disconnect_dest_from_output(&self, dest: &dyn AudioNode, output: usize)

Disconnects a specific output of the AudioNode to a specific destination AudioNode

fn disconnect_dest_from_output_to_input( &self, dest: &dyn AudioNode, output: usize, input: usize, )

Disconnects a specific output of the AudioNode to a specific input of some destination 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

fn set_onprocessorerror( &self, callback: Box<dyn FnOnce(ErrorEvent) + Send + 'static>, )

Register callback to run when an unhandled exception occurs in the audio processor.

fn clear_onprocessorerror(&self)

Unset the callback to run when an unhandled exception occurs in the audio processor.

impl Debug for MediaStreamAudioDestinationNode

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

Formats the value using the given formatter.