Struct web_audio_api::node::BiquadFilterNode

pub struct BiquadFilterNode { /* private fields */ }

BiquadFilterNode is an AudioNode processor implementing very common low-order IIR filters.

Low-order filters are the building blocks of basic tone controls (bass, mid, treble), graphic equalizers, and more advanced filters. Multiple BiquadFilterNode filters can be combined to form more complex filters.

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

Usage

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

let context = AudioContext::default();

let file = File::open("samples/think-stereo-48000.wav").unwrap();
let buffer = context.decode_audio_data_sync(file).unwrap();

// create a lowpass filter (default) and open frequency parameter over time
let biquad = context.create_biquad_filter();
biquad.connect(&context.destination());
biquad.frequency().set_value(10.);
biquad
    .frequency()
    .exponential_ramp_to_value_at_time(10000., context.current_time() + 10.);

// pipe the audio buffer source into the lowpass filter
let src = context.create_buffer_source();
src.connect(&biquad);
src.set_buffer(buffer);
src.set_loop(true);
src.start();

Examples

• cargo run --release --example biquad

Implementations

impl BiquadFilterNode

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

returns a BiquadFilterNode instance

Arguments

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

pub fn gain(&self) -> &AudioParam

Returns the gain audio paramter

pub fn frequency(&self) -> &AudioParam

Returns the frequency audio paramter

pub fn detune(&self) -> &AudioParam

Returns the detune audio paramter

pub fn q(&self) -> &AudioParam

Returns the Q audio paramter

pub fn type_(&self) -> BiquadFilterType

Returns the biquad filter type

pub fn set_type(&self, type_: BiquadFilterType)

biquad filter type setter

Arguments

• type_ - the biquad filter type (lowpass, highpass,…)

pub fn get_frequency_response(
    &self,
    frequency_hz: &[f32],
    mag_response: &mut [f32],
    phase_response: &mut [f32]
)

Returns the frequency response for the specified frequencies

Arguments

• frequency_hz - frequencies for which frequency response of the filter should be calculated
• mag_response - magnitude of the frequency response of the filter
• phase_response - phase of the frequency response of the filter

Panics

This function will panic if arguments’ lengths don’t match

Trait Implementations

impl AudioNode for BiquadFilterNode

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