Struct ConstantSourceNode

pub struct ConstantSourceNode { /* private fields */ }

Audio source whose output is nominally a constant value. A ConstantSourceNode can be used as a constructible AudioParam by automating the value of its offset.

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

Usage

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

let audio_context = AudioContext::default();

let gain1 = audio_context.create_gain();
gain1.gain().set_value(0.);

let gain2 = audio_context.create_gain();
gain2.gain().set_value(0.);

let automation = audio_context.create_constant_source();
automation.offset().set_value(0.);
automation.connect(gain1.gain());
automation.connect(gain2.gain());

// control both `GainNode`s with 1 automation
automation.offset().set_target_at_time(1., audio_context.current_time(), 0.1);

Example

• cargo run --release --example constant_source

Implementations

impl ConstantSourceNode

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

pub fn offset(&self) -> &AudioParam

Trait Implementations

impl AudioNode for ConstantSourceNode

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 AudioScheduledSourceNode for ConstantSourceNode

fn start(&mut self)

Play immediately

fn start_at(&mut self, when: f64)

Schedule playback start at given timestamp

fn stop(&mut self)

Stop immediately

fn stop_at(&mut self, when: f64)

Schedule playback stop at given timestamp

fn set_onended<F: FnOnce(Event) + Send + 'static>(&self, callback: F)

Register callback to run when the source node has stopped playing

fn clear_onended(&self)

Unset the callback to run when the source node has stopped playing

impl Debug for ConstantSourceNode

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

Formats the value using the given formatter.