Struct web_audio_api::node::IIRFilterNode

pub struct IIRFilterNode { /* private fields */ }

IIRFilterNode is an AudioNode processor implementing a general IIR (infinite impulse response)Filter.

In general, you should prefer using a BiquadFilterNode for the following reasons:

• Generally less sensitive to numeric issues
• Filter parameters can be automated
• Can be used to create all even-ordered IIR filters

However, odd-ordered filters cannot be created with BiquadFilterNode, so if your application require such filters and/or automation is not needed, then IIR filters may be appropriate. In short, use this if you know what you are doing!

Note that once created, the coefficients of the IIR filter cannot be changed.

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

Usage

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

// create context and grab some audio buffer
let context = AudioContext::default();
let file = File::open("samples/think-stereo-48000.wav").unwrap();
let buffer = context.decode_audio_data_sync(file).unwrap();

// these coefficients correspond to a lowpass filter at 200Hz (calculated from biquad)
let feedforward = vec![
    0.0002029799640409502,
    0.0004059599280819004,
    0.0002029799640409502,
];

let feedback = vec![
    1.0126964557853775,
    -1.9991880801438362,
    0.9873035442146225,
];

// create the IIR filter node
let iir = context.create_iir_filter(feedforward, feedback);
iir.connect(&context.destination());

// play the buffer and pipe it into the filter
let src = context.create_buffer_source();
src.connect(&iir);
src.set_buffer(buffer);
src.set_loop(true);
src.start();

Examples

• cargo run --release --example iir

Implementations

impl IIRFilterNode

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

Creates an IirFilterNode

Arguments

• context - Audio context in which the node will live
• options - node options

Panics

This function panics if:

• coefs length is 0 and greater than 20
• feedforward coefs are all zeros
• feedback first coef is zero

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 IIRFilterNode

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