Struct web_audio_api::node::ConvolverNode

pub struct ConvolverNode { /* private fields */ }

Processing node which applies a linear convolution effect given an impulse response.

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

The current implementation only handles mono-to-mono convolutions. The provided impulse response buffer and the input signal will be downmixed appropriately.

Usage

use std::fs::File;

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

let context = AudioContext::default();
let file = File::open("samples/vocals-dry.wav").unwrap();
let audio_buffer = context.decode_audio_data_sync(file).unwrap();

let impulse_file = File::open("samples/small-room-response.wav").unwrap();
let impulse_buffer = context.decode_audio_data_sync(impulse_file).unwrap();

let src = context.create_buffer_source();
src.set_buffer(audio_buffer);

let convolve = ConvolverNode::new(&context, ConvolverOptions::default());
convolve.set_buffer(impulse_buffer);

src.connect(&convolve);
convolve.connect(&context.destination());
src.start();
std::thread::sleep(std::time::Duration::from_millis(4_000));

Examples

• cargo run --release --example convolution

Implementations

impl ConvolverNode

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

returns a ConvolverNode instance

Arguments

• context - audio context in which the audio node will live.
• options - convolver options

Panics

Panics when an AudioBuffer is provided via the ConvolverOptions with a sample rate different from the audio context sample rate.

pub fn buffer(&self) -> Option<AudioBuffer>

Get the current impulse response buffer

pub fn set_buffer(&self, buffer: AudioBuffer)

Set or update the impulse response buffer

Panics

Panics when the sample rate of the provided AudioBuffer differs from the audio context sample rate.

pub fn normalize(&self) -> bool

Denotes if the response buffer will be scaled with an equal-power normalization

pub fn set_normalize(&self, value: bool)

Update the normalize setting. This will only have an effect when set_buffer is called.

Trait Implementations

impl AudioNode for ConvolverNode

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